atlas.js-protos 0.1.0

package/dist/types/atlas/storage/v1/tx.mjs

@@ -0,0 +1,1167 @@
+//@ts-nocheck
+import { Params } from "./params";
+import * as _m0 from "protobufjs/minimal";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseMsgUpdateParams() {
+    return {
+        authority: "",
+        params: Params.fromPartial({})
+    };
+}
+/**
+ * MsgUpdateParams is the Msg/UpdateParams request type.
+ * @name MsgUpdateParams
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgUpdateParams
+ */
+export const MsgUpdateParams = {
+    typeUrl: "/atlas.storage.v1.MsgUpdateParams",
+    aminoType: "atlas/x/storage/MsgUpdateParams",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.is(o.params));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgUpdateParams.typeUrl || typeof o.authority === "string" && Params.isSDK(o.params));
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.authority !== "") {
+            writer.uint32(10).string(message.authority);
+        }
+        if (message.params !== undefined) {
+            Params.encode(message.params, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.authority = reader.string();
+                    break;
+                case 2:
+                    message.params = Params.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateParams();
+        message.authority = object.authority ?? "";
+        message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParams.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParams.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgUpdateParams",
+            value: MsgUpdateParams.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(MsgUpdateParams.typeUrl)) {
+            return;
+        }
+        Params.registerTypeUrl();
+    }
+};
+GlobalDecoderRegistry.register(MsgUpdateParams.typeUrl, MsgUpdateParams);
+GlobalDecoderRegistry.registerAminoProtoMapping(MsgUpdateParams.aminoType, MsgUpdateParams.typeUrl);
+function createBaseMsgUpdateParamsResponse() {
+    return {};
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ * @name MsgUpdateParamsResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgUpdateParamsResponse
+ */
+export const MsgUpdateParamsResponse = {
+    typeUrl: "/atlas.storage.v1.MsgUpdateParamsResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgUpdateParamsResponse.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateParamsResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateParamsResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateParamsResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateParamsResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgUpdateParamsResponse",
+            value: MsgUpdateParamsResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgUpdateParamsResponse.typeUrl, MsgUpdateParamsResponse);
+function createBaseMsgRegisterProvider() {
+    return {
+        creator: "",
+        hostname: "",
+        capacity: 0
+    };
+}
+/**
+ * MsgRegisterProvider defines the MsgRegisterProvider message.
+ * @name MsgRegisterProvider
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgRegisterProvider
+ */
+export const MsgRegisterProvider = {
+    typeUrl: "/atlas.storage.v1.MsgRegisterProvider",
+    is(o) {
+        return o && (o.$typeUrl === MsgRegisterProvider.typeUrl || typeof o.creator === "string" && typeof o.hostname === "string" && typeof o.capacity === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgRegisterProvider.typeUrl || typeof o.creator === "string" && typeof o.hostname === "string" && typeof o.capacity === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.hostname !== "") {
+            writer.uint32(18).string(message.hostname);
+        }
+        if (message.capacity !== 0) {
+            writer.uint32(24).int64(message.capacity);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRegisterProvider();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.hostname = reader.string();
+                    break;
+                case 3:
+                    message.capacity = Number(reader.int64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgRegisterProvider();
+        message.creator = object.creator ?? "";
+        message.hostname = object.hostname ?? "";
+        message.capacity = object.capacity !== undefined && object.capacity !== null ? Number(object.capacity.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterProvider.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterProvider.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgRegisterProvider",
+            value: MsgRegisterProvider.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgRegisterProvider.typeUrl, MsgRegisterProvider);
+function createBaseMsgRegisterProviderResponse() {
+    return {};
+}
+/**
+ * MsgRegisterProviderResponse defines the MsgRegisterProviderResponse message.
+ * @name MsgRegisterProviderResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgRegisterProviderResponse
+ */
+export const MsgRegisterProviderResponse = {
+    typeUrl: "/atlas.storage.v1.MsgRegisterProviderResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgRegisterProviderResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgRegisterProviderResponse.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgRegisterProviderResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgRegisterProviderResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgRegisterProviderResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgRegisterProviderResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgRegisterProviderResponse",
+            value: MsgRegisterProviderResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgRegisterProviderResponse.typeUrl, MsgRegisterProviderResponse);
+function createBaseMsgPostFile() {
+    return {
+        creator: "",
+        fid: "",
+        merkle: new Uint8Array(),
+        fileSize: 0,
+        replicas: 0,
+        subscription: ""
+    };
+}
+/**
+ * MsgPostFile defines the MsgPostFile message.
+ * @name MsgPostFile
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgPostFile
+ */
+export const MsgPostFile = {
+    typeUrl: "/atlas.storage.v1.MsgPostFile",
+    is(o) {
+        return o && (o.$typeUrl === MsgPostFile.typeUrl || typeof o.creator === "string" && typeof o.fid === "string" && (o.merkle instanceof Uint8Array || typeof o.merkle === "string") && typeof o.fileSize === "bigint" && typeof o.replicas === "number" && typeof o.subscription === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgPostFile.typeUrl || typeof o.creator === "string" && typeof o.fid === "string" && (o.merkle instanceof Uint8Array || typeof o.merkle === "string") && typeof o.file_size === "bigint" && typeof o.replicas === "number" && typeof o.subscription === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.fid !== "") {
+            writer.uint32(18).string(message.fid);
+        }
+        if (message.merkle.length !== 0) {
+            writer.uint32(26).bytes(message.merkle);
+        }
+        if (message.fileSize !== 0) {
+            writer.uint32(32).int64(message.fileSize);
+        }
+        if (message.replicas !== 0) {
+            writer.uint32(40).int32(message.replicas);
+        }
+        if (message.subscription !== "") {
+            writer.uint32(50).string(message.subscription);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgPostFile();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.fid = reader.string();
+                    break;
+                case 3:
+                    message.merkle = reader.bytes();
+                    break;
+                case 4:
+                    message.fileSize = Number(reader.int64().toString());
+                    break;
+                case 5:
+                    message.replicas = reader.int32();
+                    break;
+                case 6:
+                    message.subscription = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgPostFile();
+        message.creator = object.creator ?? "";
+        message.fid = object.fid ?? "";
+        message.merkle = object.merkle ?? new Uint8Array();
+        message.fileSize = object.fileSize !== undefined && object.fileSize !== null ? Number(object.fileSize.toString()) : 0;
+        message.replicas = object.replicas ?? 0;
+        message.subscription = object.subscription ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgPostFile.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPostFile.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgPostFile",
+            value: MsgPostFile.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgPostFile.typeUrl, MsgPostFile);
+function createBaseMsgPostFileResponse() {
+    return {
+        startBlock: 0
+    };
+}
+/**
+ * MsgPostFileResponse defines the MsgPostFileResponse message.
+ * @name MsgPostFileResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgPostFileResponse
+ */
+export const MsgPostFileResponse = {
+    typeUrl: "/atlas.storage.v1.MsgPostFileResponse",
+    is(o) {
+        return o && (o.$typeUrl === MsgPostFileResponse.typeUrl || typeof o.startBlock === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgPostFileResponse.typeUrl || typeof o.start_block === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.startBlock !== 0) {
+            writer.uint32(8).int64(message.startBlock);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgPostFileResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.startBlock = Number(reader.int64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgPostFileResponse();
+        message.startBlock = object.startBlock !== undefined && object.startBlock !== null ? Number(object.startBlock.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgPostFileResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgPostFileResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgPostFileResponse",
+            value: MsgPostFileResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgPostFileResponse.typeUrl, MsgPostFileResponse);
+function createBaseMsgBuyStorage() {
+    return {
+        creator: "",
+        receiver: "",
+        duration: 0,
+        bytes: 0,
+        isDefault: false
+    };
+}
+/**
+ * MsgBuyStorage defines the MsgBuyStorage message.
+ * @name MsgBuyStorage
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgBuyStorage
+ */
+export const MsgBuyStorage = {
+    typeUrl: "/atlas.storage.v1.MsgBuyStorage",
+    is(o) {
+        return o && (o.$typeUrl === MsgBuyStorage.typeUrl || typeof o.creator === "string" && typeof o.receiver === "string" && typeof o.duration === "bigint" && typeof o.bytes === "bigint" && typeof o.isDefault === "boolean");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgBuyStorage.typeUrl || typeof o.creator === "string" && typeof o.receiver === "string" && typeof o.duration === "bigint" && typeof o.bytes === "bigint" && typeof o.is_default === "boolean");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.receiver !== "") {
+            writer.uint32(18).string(message.receiver);
+        }
+        if (message.duration !== 0) {
+            writer.uint32(24).int64(message.duration);
+        }
+        if (message.bytes !== 0) {
+            writer.uint32(32).int64(message.bytes);
+        }
+        if (message.isDefault === true) {
+            writer.uint32(40).bool(message.isDefault);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgBuyStorage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.receiver = reader.string();
+                    break;
+                case 3:
+                    message.duration = Number(reader.int64().toString());
+                    break;
+                case 4:
+                    message.bytes = Number(reader.int64().toString());
+                    break;
+                case 5:
+                    message.isDefault = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBuyStorage();
+        message.creator = object.creator ?? "";
+        message.receiver = object.receiver ?? "";
+        message.duration = object.duration !== undefined && object.duration !== null ? Number(object.duration.toString()) : 0;
+        message.bytes = object.bytes !== undefined && object.bytes !== null ? Number(object.bytes.toString()) : 0;
+        message.isDefault = object.isDefault ?? false;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgBuyStorage.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBuyStorage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgBuyStorage",
+            value: MsgBuyStorage.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgBuyStorage.typeUrl, MsgBuyStorage);
+function createBaseMsgBuyStorageResponse() {
+    return {
+        subscriptionId: ""
+    };
+}
+/**
+ * MsgBuyStorageResponse defines the MsgBuyStorageResponse message.
+ * @name MsgBuyStorageResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgBuyStorageResponse
+ */
+export const MsgBuyStorageResponse = {
+    typeUrl: "/atlas.storage.v1.MsgBuyStorageResponse",
+    is(o) {
+        return o && (o.$typeUrl === MsgBuyStorageResponse.typeUrl || typeof o.subscriptionId === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgBuyStorageResponse.typeUrl || typeof o.SubscriptionId === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.subscriptionId !== "") {
+            writer.uint32(10).string(message.subscriptionId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgBuyStorageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.subscriptionId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgBuyStorageResponse();
+        message.subscriptionId = object.subscriptionId ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgBuyStorageResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgBuyStorageResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgBuyStorageResponse",
+            value: MsgBuyStorageResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgBuyStorageResponse.typeUrl, MsgBuyStorageResponse);
+function createBaseMsgProveFile() {
+    return {
+        creator: "",
+        challengeId: "",
+        fid: "",
+        data: new Uint8Array(),
+        hashes: [],
+        chunk: 0,
+        path: 0
+    };
+}
+/**
+ * MsgProveFile defines the MsgProveFile message.
+ * @name MsgProveFile
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgProveFile
+ */
+export const MsgProveFile = {
+    typeUrl: "/atlas.storage.v1.MsgProveFile",
+    is(o) {
+        return o && (o.$typeUrl === MsgProveFile.typeUrl || typeof o.creator === "string" && typeof o.challengeId === "string" && typeof o.fid === "string" && (o.data instanceof Uint8Array || typeof o.data === "string") && Array.isArray(o.hashes) && (!o.hashes.length || o.hashes[0] instanceof Uint8Array || typeof o.hashes[0] === "string") && typeof o.chunk === "bigint" && typeof o.path === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgProveFile.typeUrl || typeof o.creator === "string" && typeof o.challenge_id === "string" && typeof o.fid === "string" && (o.data instanceof Uint8Array || typeof o.data === "string") && Array.isArray(o.hashes) && (!o.hashes.length || o.hashes[0] instanceof Uint8Array || typeof o.hashes[0] === "string") && typeof o.chunk === "bigint" && typeof o.path === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.challengeId !== "") {
+            writer.uint32(18).string(message.challengeId);
+        }
+        if (message.fid !== "") {
+            writer.uint32(26).string(message.fid);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(34).bytes(message.data);
+        }
+        for (const v of message.hashes) {
+            writer.uint32(42).bytes(v);
+        }
+        if (message.chunk !== 0) {
+            writer.uint32(48).uint64(message.chunk);
+        }
+        if (message.path !== 0) {
+            writer.uint32(56).uint64(message.path);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgProveFile();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.challengeId = reader.string();
+                    break;
+                case 3:
+                    message.fid = reader.string();
+                    break;
+                case 4:
+                    message.data = reader.bytes();
+                    break;
+                case 5:
+                    message.hashes.push(reader.bytes());
+                    break;
+                case 6:
+                    message.chunk = Number(reader.uint64().toString());
+                    break;
+                case 7:
+                    message.path = Number(reader.uint64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgProveFile();
+        message.creator = object.creator ?? "";
+        message.challengeId = object.challengeId ?? "";
+        message.fid = object.fid ?? "";
+        message.data = object.data ?? new Uint8Array();
+        message.hashes = object.hashes?.map(e => e) || [];
+        message.chunk = object.chunk !== undefined && object.chunk !== null ? Number(object.chunk.toString()) : 0;
+        message.path = object.path !== undefined && object.path !== null ? Number(object.path.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgProveFile.decode(message.value);
+    },
+    toProto(message) {
+        return MsgProveFile.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgProveFile",
+            value: MsgProveFile.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgProveFile.typeUrl, MsgProveFile);
+function createBaseMsgProveFileResponse() {
+    return {};
+}
+/**
+ * MsgProveFileResponse defines the MsgProveFileResponse message.
+ * @name MsgProveFileResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgProveFileResponse
+ */
+export const MsgProveFileResponse = {
+    typeUrl: "/atlas.storage.v1.MsgProveFileResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgProveFileResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgProveFileResponse.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgProveFileResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgProveFileResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgProveFileResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgProveFileResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgProveFileResponse",
+            value: MsgProveFileResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgProveFileResponse.typeUrl, MsgProveFileResponse);
+function createBaseMsgDeleteFile() {
+    return {
+        creator: "",
+        fileId: ""
+    };
+}
+/**
+ * MsgDeleteFile defines the MsgDeleteFile message.
+ * @name MsgDeleteFile
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgDeleteFile
+ */
+export const MsgDeleteFile = {
+    typeUrl: "/atlas.storage.v1.MsgDeleteFile",
+    is(o) {
+        return o && (o.$typeUrl === MsgDeleteFile.typeUrl || typeof o.creator === "string" && typeof o.fileId === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgDeleteFile.typeUrl || typeof o.creator === "string" && typeof o.file_id === "string");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.fileId !== "") {
+            writer.uint32(18).string(message.fileId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgDeleteFile();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.fileId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgDeleteFile();
+        message.creator = object.creator ?? "";
+        message.fileId = object.fileId ?? "";
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteFile.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteFile.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgDeleteFile",
+            value: MsgDeleteFile.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgDeleteFile.typeUrl, MsgDeleteFile);
+function createBaseMsgDeleteFileResponse() {
+    return {};
+}
+/**
+ * MsgDeleteFileResponse defines the MsgDeleteFileResponse message.
+ * @name MsgDeleteFileResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgDeleteFileResponse
+ */
+export const MsgDeleteFileResponse = {
+    typeUrl: "/atlas.storage.v1.MsgDeleteFileResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgDeleteFileResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgDeleteFileResponse.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgDeleteFileResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgDeleteFileResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgDeleteFileResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgDeleteFileResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgDeleteFileResponse",
+            value: MsgDeleteFileResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgDeleteFileResponse.typeUrl, MsgDeleteFileResponse);
+function createBaseMsgExpandStorage() {
+    return {
+        creator: "",
+        subscriptionId: "",
+        duration: 0,
+        bytes: 0
+    };
+}
+/**
+ * MsgExpandStorage defines the MsgExpandStorage message.
+ * @name MsgExpandStorage
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgExpandStorage
+ */
+export const MsgExpandStorage = {
+    typeUrl: "/atlas.storage.v1.MsgExpandStorage",
+    is(o) {
+        return o && (o.$typeUrl === MsgExpandStorage.typeUrl || typeof o.creator === "string" && typeof o.subscriptionId === "string" && typeof o.duration === "bigint" && typeof o.bytes === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgExpandStorage.typeUrl || typeof o.creator === "string" && typeof o.subscription_id === "string" && typeof o.duration === "bigint" && typeof o.bytes === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.subscriptionId !== "") {
+            writer.uint32(18).string(message.subscriptionId);
+        }
+        if (message.duration !== 0) {
+            writer.uint32(24).int64(message.duration);
+        }
+        if (message.bytes !== 0) {
+            writer.uint32(32).int64(message.bytes);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgExpandStorage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.subscriptionId = reader.string();
+                    break;
+                case 3:
+                    message.duration = Number(reader.int64().toString());
+                    break;
+                case 4:
+                    message.bytes = Number(reader.int64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgExpandStorage();
+        message.creator = object.creator ?? "";
+        message.subscriptionId = object.subscriptionId ?? "";
+        message.duration = object.duration !== undefined && object.duration !== null ? Number(object.duration.toString()) : 0;
+        message.bytes = object.bytes !== undefined && object.bytes !== null ? Number(object.bytes.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgExpandStorage.decode(message.value);
+    },
+    toProto(message) {
+        return MsgExpandStorage.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgExpandStorage",
+            value: MsgExpandStorage.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgExpandStorage.typeUrl, MsgExpandStorage);
+function createBaseMsgExpandStorageResponse() {
+    return {
+        subscriptionId: "",
+        newExpiration: 0,
+        newSpaceAvailable: 0
+    };
+}
+/**
+ * MsgExpandStorageResponse defines the MsgExpandStorageResponse message.
+ * @name MsgExpandStorageResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgExpandStorageResponse
+ */
+export const MsgExpandStorageResponse = {
+    typeUrl: "/atlas.storage.v1.MsgExpandStorageResponse",
+    is(o) {
+        return o && (o.$typeUrl === MsgExpandStorageResponse.typeUrl || typeof o.subscriptionId === "string" && typeof o.newExpiration === "bigint" && typeof o.newSpaceAvailable === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgExpandStorageResponse.typeUrl || typeof o.subscription_id === "string" && typeof o.new_expiration === "bigint" && typeof o.new_space_available === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.subscriptionId !== "") {
+            writer.uint32(10).string(message.subscriptionId);
+        }
+        if (message.newExpiration !== 0) {
+            writer.uint32(16).int64(message.newExpiration);
+        }
+        if (message.newSpaceAvailable !== 0) {
+            writer.uint32(24).int64(message.newSpaceAvailable);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgExpandStorageResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.subscriptionId = reader.string();
+                    break;
+                case 2:
+                    message.newExpiration = Number(reader.int64().toString());
+                    break;
+                case 3:
+                    message.newSpaceAvailable = Number(reader.int64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgExpandStorageResponse();
+        message.subscriptionId = object.subscriptionId ?? "";
+        message.newExpiration = object.newExpiration !== undefined && object.newExpiration !== null ? Number(object.newExpiration.toString()) : 0;
+        message.newSpaceAvailable = object.newSpaceAvailable !== undefined && object.newSpaceAvailable !== null ? Number(object.newSpaceAvailable.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgExpandStorageResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgExpandStorageResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgExpandStorageResponse",
+            value: MsgExpandStorageResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgExpandStorageResponse.typeUrl, MsgExpandStorageResponse);
+function createBaseMsgUpdateProvider() {
+    return {
+        creator: "",
+        hostname: "",
+        capacity: 0
+    };
+}
+/**
+ * MsgUpdateProvider defines the MsgUpdateProvider message.
+ * @name MsgUpdateProvider
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgUpdateProvider
+ */
+export const MsgUpdateProvider = {
+    typeUrl: "/atlas.storage.v1.MsgUpdateProvider",
+    is(o) {
+        return o && (o.$typeUrl === MsgUpdateProvider.typeUrl || typeof o.creator === "string" && typeof o.hostname === "string" && typeof o.capacity === "bigint");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MsgUpdateProvider.typeUrl || typeof o.creator === "string" && typeof o.hostname === "string" && typeof o.capacity === "bigint");
+    },
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.creator !== "") {
+            writer.uint32(10).string(message.creator);
+        }
+        if (message.hostname !== "") {
+            writer.uint32(18).string(message.hostname);
+        }
+        if (message.capacity !== 0) {
+            writer.uint32(24).int64(message.capacity);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateProvider();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.creator = reader.string();
+                    break;
+                case 2:
+                    message.hostname = reader.string();
+                    break;
+                case 3:
+                    message.capacity = Number(reader.int64().toString());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseMsgUpdateProvider();
+        message.creator = object.creator ?? "";
+        message.hostname = object.hostname ?? "";
+        message.capacity = object.capacity !== undefined && object.capacity !== null ? Number(object.capacity.toString()) : 0;
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateProvider.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateProvider.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgUpdateProvider",
+            value: MsgUpdateProvider.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgUpdateProvider.typeUrl, MsgUpdateProvider);
+function createBaseMsgUpdateProviderResponse() {
+    return {};
+}
+/**
+ * MsgUpdateProviderResponse defines the MsgUpdateProviderResponse message.
+ * @name MsgUpdateProviderResponse
+ * @package atlas.storage.v1
+ * @see proto type: atlas.storage.v1.MsgUpdateProviderResponse
+ */
+export const MsgUpdateProviderResponse = {
+    typeUrl: "/atlas.storage.v1.MsgUpdateProviderResponse",
+    is(o) {
+        return o && o.$typeUrl === MsgUpdateProviderResponse.typeUrl;
+    },
+    isSDK(o) {
+        return o && o.$typeUrl === MsgUpdateProviderResponse.typeUrl;
+    },
+    encode(_, writer = _m0.Writer.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMsgUpdateProviderResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseMsgUpdateProviderResponse();
+        return message;
+    },
+    fromProtoMsg(message) {
+        return MsgUpdateProviderResponse.decode(message.value);
+    },
+    toProto(message) {
+        return MsgUpdateProviderResponse.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/atlas.storage.v1.MsgUpdateProviderResponse",
+            value: MsgUpdateProviderResponse.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+GlobalDecoderRegistry.register(MsgUpdateProviderResponse.typeUrl, MsgUpdateProviderResponse);