@manifest-network/manifestjs 2.1.0

package/dist/codegen/cosmos/app/v1alpha1/module.mjs

@@ -0,0 +1,335 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { isSet } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+function createBaseModuleDescriptor() {
+    return {
+        goImport: "",
+        usePackage: [],
+        canMigrateFrom: []
+    };
+}
+export const ModuleDescriptor = {
+    typeUrl: "/cosmos.app.v1alpha1.ModuleDescriptor",
+    aminoType: "cosmos-sdk/ModuleDescriptor",
+    is(o) {
+        return o && (o.$typeUrl === ModuleDescriptor.typeUrl || typeof o.goImport === "string" && Array.isArray(o.usePackage) && (!o.usePackage.length || PackageReference.is(o.usePackage[0])) && Array.isArray(o.canMigrateFrom) && (!o.canMigrateFrom.length || MigrateFromInfo.is(o.canMigrateFrom[0])));
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === ModuleDescriptor.typeUrl || typeof o.go_import === "string" && Array.isArray(o.use_package) && (!o.use_package.length || PackageReference.isSDK(o.use_package[0])) && Array.isArray(o.can_migrate_from) && (!o.can_migrate_from.length || MigrateFromInfo.isSDK(o.can_migrate_from[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ModuleDescriptor.typeUrl || typeof o.go_import === "string" && Array.isArray(o.use_package) && (!o.use_package.length || PackageReference.isAmino(o.use_package[0])) && Array.isArray(o.can_migrate_from) && (!o.can_migrate_from.length || MigrateFromInfo.isAmino(o.can_migrate_from[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.goImport !== "") {
+            writer.uint32(10).string(message.goImport);
+        }
+        for (const v of message.usePackage) {
+            PackageReference.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        for (const v of message.canMigrateFrom) {
+            MigrateFromInfo.encode(v, writer.uint32(26).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 = createBaseModuleDescriptor();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.goImport = reader.string();
+                    break;
+                case 2:
+                    message.usePackage.push(PackageReference.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.canMigrateFrom.push(MigrateFromInfo.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            goImport: isSet(object.goImport) ? String(object.goImport) : "",
+            usePackage: Array.isArray(object?.usePackage) ? object.usePackage.map((e) => PackageReference.fromJSON(e)) : [],
+            canMigrateFrom: Array.isArray(object?.canMigrateFrom) ? object.canMigrateFrom.map((e) => MigrateFromInfo.fromJSON(e)) : []
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.goImport !== undefined && (obj.goImport = message.goImport);
+        if (message.usePackage) {
+            obj.usePackage = message.usePackage.map(e => e ? PackageReference.toJSON(e) : undefined);
+        }
+        else {
+            obj.usePackage = [];
+        }
+        if (message.canMigrateFrom) {
+            obj.canMigrateFrom = message.canMigrateFrom.map(e => e ? MigrateFromInfo.toJSON(e) : undefined);
+        }
+        else {
+            obj.canMigrateFrom = [];
+        }
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseModuleDescriptor();
+        message.goImport = object.goImport ?? "";
+        message.usePackage = object.usePackage?.map(e => PackageReference.fromPartial(e)) || [];
+        message.canMigrateFrom = object.canMigrateFrom?.map(e => MigrateFromInfo.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseModuleDescriptor();
+        if (object.go_import !== undefined && object.go_import !== null) {
+            message.goImport = object.go_import;
+        }
+        message.usePackage = object.use_package?.map(e => PackageReference.fromAmino(e)) || [];
+        message.canMigrateFrom = object.can_migrate_from?.map(e => MigrateFromInfo.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.go_import = message.goImport === "" ? undefined : message.goImport;
+        if (message.usePackage) {
+            obj.use_package = message.usePackage.map(e => e ? PackageReference.toAmino(e) : undefined);
+        }
+        else {
+            obj.use_package = message.usePackage;
+        }
+        if (message.canMigrateFrom) {
+            obj.can_migrate_from = message.canMigrateFrom.map(e => e ? MigrateFromInfo.toAmino(e) : undefined);
+        }
+        else {
+            obj.can_migrate_from = message.canMigrateFrom;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ModuleDescriptor.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/ModuleDescriptor",
+            value: ModuleDescriptor.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return ModuleDescriptor.decode(message.value);
+    },
+    toProto(message) {
+        return ModuleDescriptor.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.app.v1alpha1.ModuleDescriptor",
+            value: ModuleDescriptor.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(ModuleDescriptor.typeUrl, ModuleDescriptor);
+GlobalDecoderRegistry.registerAminoProtoMapping(ModuleDescriptor.aminoType, ModuleDescriptor.typeUrl);
+function createBasePackageReference() {
+    return {
+        name: "",
+        revision: 0
+    };
+}
+export const PackageReference = {
+    typeUrl: "/cosmos.app.v1alpha1.PackageReference",
+    aminoType: "cosmos-sdk/PackageReference",
+    is(o) {
+        return o && (o.$typeUrl === PackageReference.typeUrl || typeof o.name === "string" && typeof o.revision === "number");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === PackageReference.typeUrl || typeof o.name === "string" && typeof o.revision === "number");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PackageReference.typeUrl || typeof o.name === "string" && typeof o.revision === "number");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.revision !== 0) {
+            writer.uint32(16).uint32(message.revision);
+        }
+        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 = createBasePackageReference();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.name = reader.string();
+                    break;
+                case 2:
+                    message.revision = reader.uint32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? String(object.name) : "",
+            revision: isSet(object.revision) ? Number(object.revision) : 0
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.name !== undefined && (obj.name = message.name);
+        message.revision !== undefined && (obj.revision = Math.round(message.revision));
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBasePackageReference();
+        message.name = object.name ?? "";
+        message.revision = object.revision ?? 0;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePackageReference();
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.revision !== undefined && object.revision !== null) {
+            message.revision = object.revision;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.revision = message.revision === 0 ? undefined : message.revision;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PackageReference.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/PackageReference",
+            value: PackageReference.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return PackageReference.decode(message.value);
+    },
+    toProto(message) {
+        return PackageReference.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.app.v1alpha1.PackageReference",
+            value: PackageReference.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(PackageReference.typeUrl, PackageReference);
+GlobalDecoderRegistry.registerAminoProtoMapping(PackageReference.aminoType, PackageReference.typeUrl);
+function createBaseMigrateFromInfo() {
+    return {
+        module: ""
+    };
+}
+export const MigrateFromInfo = {
+    typeUrl: "/cosmos.app.v1alpha1.MigrateFromInfo",
+    aminoType: "cosmos-sdk/MigrateFromInfo",
+    is(o) {
+        return o && (o.$typeUrl === MigrateFromInfo.typeUrl || typeof o.module === "string");
+    },
+    isSDK(o) {
+        return o && (o.$typeUrl === MigrateFromInfo.typeUrl || typeof o.module === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === MigrateFromInfo.typeUrl || typeof o.module === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.module !== "") {
+            writer.uint32(10).string(message.module);
+        }
+        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 = createBaseMigrateFromInfo();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.module = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            module: isSet(object.module) ? String(object.module) : ""
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.module !== undefined && (obj.module = message.module);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseMigrateFromInfo();
+        message.module = object.module ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseMigrateFromInfo();
+        if (object.module !== undefined && object.module !== null) {
+            message.module = object.module;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.module = message.module === "" ? undefined : message.module;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return MigrateFromInfo.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/MigrateFromInfo",
+            value: MigrateFromInfo.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return MigrateFromInfo.decode(message.value);
+    },
+    toProto(message) {
+        return MigrateFromInfo.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.app.v1alpha1.MigrateFromInfo",
+            value: MigrateFromInfo.encode(message).finish()
+        };
+    }
+};
+GlobalDecoderRegistry.register(MigrateFromInfo.typeUrl, MigrateFromInfo);
+GlobalDecoderRegistry.registerAminoProtoMapping(MigrateFromInfo.aminoType, MigrateFromInfo.typeUrl);
+//# sourceMappingURL=module.js.map

package/dist/codegen/cosmos/auth/v1beta1/auth.d.ts

@@ -0,0 +1,228 @@
+import { Any, AnyAmino, AnySDKType } from "../../../google/protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial, Exact } from "../../../helpers";
+import { JsonSafe } from "../../../json-safe";
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccount {
+    $typeUrl?: "/cosmos.auth.v1beta1.BaseAccount";
+    address: string;
+    pubKey?: Any;
+    accountNumber: bigint;
+    sequence: bigint;
+}
+export interface BaseAccountProtoMsg {
+    typeUrl: "/cosmos.auth.v1beta1.BaseAccount";
+    value: Uint8Array;
+}
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccountAmino {
+    address?: string;
+    pub_key?: AnyAmino;
+    account_number?: string;
+    sequence?: string;
+}
+export interface BaseAccountAminoMsg {
+    type: "cosmos-sdk/BaseAccount";
+    value: BaseAccountAmino;
+}
+/**
+ * BaseAccount defines a base account type. It contains all the necessary fields
+ * for basic account functionality. Any custom account type should extend this
+ * type for additional functionality (e.g. vesting).
+ */
+export interface BaseAccountSDKType {
+    $typeUrl?: "/cosmos.auth.v1beta1.BaseAccount";
+    address: string;
+    pub_key?: AnySDKType;
+    account_number: bigint;
+    sequence: bigint;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccount {
+    $typeUrl?: "/cosmos.auth.v1beta1.ModuleAccount";
+    baseAccount?: BaseAccount;
+    name: string;
+    permissions: string[];
+}
+export interface ModuleAccountProtoMsg {
+    typeUrl: "/cosmos.auth.v1beta1.ModuleAccount";
+    value: Uint8Array;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccountAmino {
+    base_account?: BaseAccountAmino;
+    name?: string;
+    permissions?: string[];
+}
+export interface ModuleAccountAminoMsg {
+    type: "cosmos-sdk/ModuleAccount";
+    value: ModuleAccountAmino;
+}
+/** ModuleAccount defines an account for modules that holds coins on a pool. */
+export interface ModuleAccountSDKType {
+    $typeUrl?: "/cosmos.auth.v1beta1.ModuleAccount";
+    base_account?: BaseAccountSDKType;
+    name: string;
+    permissions: string[];
+}
+/**
+ * ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface ModuleCredential {
+    /** module_name is the name of the module used for address derivation (passed into address.Module). */
+    moduleName: string;
+    /**
+     * derivation_keys is for deriving a module account address (passed into address.Module)
+     * adding more keys creates sub-account addresses (passed into address.Derive)
+     */
+    derivationKeys: Uint8Array[];
+}
+export interface ModuleCredentialProtoMsg {
+    typeUrl: "/cosmos.auth.v1beta1.ModuleCredential";
+    value: Uint8Array;
+}
+/**
+ * ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface ModuleCredentialAmino {
+    /** module_name is the name of the module used for address derivation (passed into address.Module). */
+    module_name?: string;
+    /**
+     * derivation_keys is for deriving a module account address (passed into address.Module)
+     * adding more keys creates sub-account addresses (passed into address.Derive)
+     */
+    derivation_keys?: string[];
+}
+export interface ModuleCredentialAminoMsg {
+    type: "cosmos-sdk/GroupAccountCredential";
+    value: ModuleCredentialAmino;
+}
+/**
+ * ModuleCredential represents a unclaimable pubkey for base accounts controlled by modules.
+ *
+ * Since: cosmos-sdk 0.47
+ */
+export interface ModuleCredentialSDKType {
+    module_name: string;
+    derivation_keys: Uint8Array[];
+}
+/** Params defines the parameters for the auth module. */
+export interface Params {
+    maxMemoCharacters: bigint;
+    txSigLimit: bigint;
+    txSizeCostPerByte: bigint;
+    sigVerifyCostEd25519: bigint;
+    sigVerifyCostSecp256k1: bigint;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/cosmos.auth.v1beta1.Params";
+    value: Uint8Array;
+}
+/** Params defines the parameters for the auth module. */
+export interface ParamsAmino {
+    max_memo_characters?: string;
+    tx_sig_limit?: string;
+    tx_size_cost_per_byte?: string;
+    sig_verify_cost_ed25519?: string;
+    sig_verify_cost_secp256k1?: string;
+}
+export interface ParamsAminoMsg {
+    type: "cosmos-sdk/x/auth/Params";
+    value: ParamsAmino;
+}
+/** Params defines the parameters for the auth module. */
+export interface ParamsSDKType {
+    max_memo_characters: bigint;
+    tx_sig_limit: bigint;
+    tx_size_cost_per_byte: bigint;
+    sig_verify_cost_ed25519: bigint;
+    sig_verify_cost_secp256k1: bigint;
+}
+export declare const BaseAccount: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is BaseAccount;
+    isSDK(o: any): o is BaseAccountSDKType;
+    isAmino(o: any): o is BaseAccountAmino;
+    encode(message: BaseAccount, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): BaseAccount;
+    fromJSON(object: any): BaseAccount;
+    toJSON(message: BaseAccount): JsonSafe<BaseAccount>;
+    fromPartial<I extends Exact<DeepPartial<BaseAccount>, I>>(object: I): BaseAccount;
+    fromAmino(object: BaseAccountAmino): BaseAccount;
+    toAmino(message: BaseAccount): BaseAccountAmino;
+    fromAminoMsg(object: BaseAccountAminoMsg): BaseAccount;
+    toAminoMsg(message: BaseAccount): BaseAccountAminoMsg;
+    fromProtoMsg(message: BaseAccountProtoMsg): BaseAccount;
+    toProto(message: BaseAccount): Uint8Array;
+    toProtoMsg(message: BaseAccount): BaseAccountProtoMsg;
+};
+export declare const ModuleAccount: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is ModuleAccount;
+    isSDK(o: any): o is ModuleAccountSDKType;
+    isAmino(o: any): o is ModuleAccountAmino;
+    encode(message: ModuleAccount, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ModuleAccount;
+    fromJSON(object: any): ModuleAccount;
+    toJSON(message: ModuleAccount): JsonSafe<ModuleAccount>;
+    fromPartial<I extends Exact<DeepPartial<ModuleAccount>, I>>(object: I): ModuleAccount;
+    fromAmino(object: ModuleAccountAmino): ModuleAccount;
+    toAmino(message: ModuleAccount): ModuleAccountAmino;
+    fromAminoMsg(object: ModuleAccountAminoMsg): ModuleAccount;
+    toAminoMsg(message: ModuleAccount): ModuleAccountAminoMsg;
+    fromProtoMsg(message: ModuleAccountProtoMsg): ModuleAccount;
+    toProto(message: ModuleAccount): Uint8Array;
+    toProtoMsg(message: ModuleAccount): ModuleAccountProtoMsg;
+};
+export declare const ModuleCredential: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is ModuleCredential;
+    isSDK(o: any): o is ModuleCredentialSDKType;
+    isAmino(o: any): o is ModuleCredentialAmino;
+    encode(message: ModuleCredential, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): ModuleCredential;
+    fromJSON(object: any): ModuleCredential;
+    toJSON(message: ModuleCredential): JsonSafe<ModuleCredential>;
+    fromPartial<I extends Exact<DeepPartial<ModuleCredential>, I>>(object: I): ModuleCredential;
+    fromAmino(object: ModuleCredentialAmino): ModuleCredential;
+    toAmino(message: ModuleCredential): ModuleCredentialAmino;
+    fromAminoMsg(object: ModuleCredentialAminoMsg): ModuleCredential;
+    toAminoMsg(message: ModuleCredential): ModuleCredentialAminoMsg;
+    fromProtoMsg(message: ModuleCredentialProtoMsg): ModuleCredential;
+    toProto(message: ModuleCredential): Uint8Array;
+    toProtoMsg(message: ModuleCredential): ModuleCredentialProtoMsg;
+};
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Params;
+    isSDK(o: any): o is ParamsSDKType;
+    isAmino(o: any): o is ParamsAmino;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromJSON(object: any): Params;
+    toJSON(message: Params): JsonSafe<Params>;
+    fromPartial<I extends Exact<DeepPartial<Params>, I>>(object: I): Params;
+    fromAmino(object: ParamsAmino): Params;
+    toAmino(message: Params): ParamsAmino;
+    fromAminoMsg(object: ParamsAminoMsg): Params;
+    toAminoMsg(message: Params): ParamsAminoMsg;
+    fromProtoMsg(message: ParamsProtoMsg): Params;
+    toProto(message: Params): Uint8Array;
+    toProtoMsg(message: Params): ParamsProtoMsg;
+};