@xpla/xplajs 1.7.0-beta.2 → 1.7.0-beta.4

package/dist/cosmos/feegrant/v1beta1/query.rpc.func.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetAllowancesByGranter = exports.createGetAllowances = exports.createGetAllowance = void 0;
+const helper_func_types_1 = require("../../../helper-func-types");
+const query_1 = require("./query");
+const createGetAllowance = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryAllowanceRequest.encode,
+    decode: query_1.QueryAllowanceResponse.decode,
+    service: "cosmos.feegrant.v1beta1.Query",
+    method: "Allowance",
+    clientResolver
+});
+exports.createGetAllowance = createGetAllowance;
+const createGetAllowances = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryAllowancesRequest.encode,
+    decode: query_1.QueryAllowancesResponse.decode,
+    service: "cosmos.feegrant.v1beta1.Query",
+    method: "Allowances",
+    clientResolver
+});
+exports.createGetAllowances = createGetAllowances;
+const createGetAllowancesByGranter = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryAllowancesByGranterRequest.encode,
+    decode: query_1.QueryAllowancesByGranterResponse.decode,
+    service: "cosmos.feegrant.v1beta1.Query",
+    method: "AllowancesByGranter",
+    clientResolver
+});
+exports.createGetAllowancesByGranter = createGetAllowancesByGranter;

package/dist/cosmos/feegrant/v1beta1/tx.amino.d.ts

@@ -0,0 +1,18 @@
+import { MsgGrantAllowance, MsgRevokeAllowance, MsgPruneAllowances } from "./tx";
+export declare const AminoConverter: {
+    "/cosmos.feegrant.v1beta1.MsgGrantAllowance": {
+        aminoType: string;
+        toAmino: (message: MsgGrantAllowance) => import("./tx").MsgGrantAllowanceAmino;
+        fromAmino: (object: import("./tx").MsgGrantAllowanceAmino) => MsgGrantAllowance;
+    };
+    "/cosmos.feegrant.v1beta1.MsgRevokeAllowance": {
+        aminoType: string;
+        toAmino: (message: MsgRevokeAllowance) => import("./tx").MsgRevokeAllowanceAmino;
+        fromAmino: (object: import("./tx").MsgRevokeAllowanceAmino) => MsgRevokeAllowance;
+    };
+    "/cosmos.feegrant.v1beta1.MsgPruneAllowances": {
+        aminoType: string;
+        toAmino: (message: MsgPruneAllowances) => import("./tx").MsgPruneAllowancesAmino;
+        fromAmino: (object: import("./tx").MsgPruneAllowancesAmino) => MsgPruneAllowances;
+    };
+};

package/dist/cosmos/feegrant/v1beta1/tx.amino.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AminoConverter = void 0;
+const tx_1 = require("./tx");
+exports.AminoConverter = {
+    "/cosmos.feegrant.v1beta1.MsgGrantAllowance": {
+        aminoType: "cosmos-sdk/MsgGrantAllowance",
+        toAmino: tx_1.MsgGrantAllowance.toAmino,
+        fromAmino: tx_1.MsgGrantAllowance.fromAmino
+    },
+    "/cosmos.feegrant.v1beta1.MsgRevokeAllowance": {
+        aminoType: "cosmos-sdk/MsgRevokeAllowance",
+        toAmino: tx_1.MsgRevokeAllowance.toAmino,
+        fromAmino: tx_1.MsgRevokeAllowance.fromAmino
+    },
+    "/cosmos.feegrant.v1beta1.MsgPruneAllowances": {
+        aminoType: "cosmos-sdk/MsgPruneAllowances",
+        toAmino: tx_1.MsgPruneAllowances.toAmino,
+        fromAmino: tx_1.MsgPruneAllowances.fromAmino
+    }
+};

package/dist/cosmos/feegrant/v1beta1/tx.d.ts

@@ -0,0 +1,233 @@
+import { Any, AnyProtoMsg, AnyAmino } from "../../../google/protobuf/any";
+import { BasicAllowance, BasicAllowanceProtoMsg, PeriodicAllowance, PeriodicAllowanceProtoMsg, AllowedMsgAllowance, AllowedMsgAllowanceProtoMsg } from "./feegrant";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * MsgGrantAllowance adds permission for Grantee to spend up to Allowance
+ * of fees from the account of Granter.
+ */
+export interface MsgGrantAllowance {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee: string;
+    /** allowance can be any of basic, periodic, allowed fee allowance. */
+    allowance?: BasicAllowance | PeriodicAllowance | AllowedMsgAllowance | Any | undefined;
+}
+export interface MsgGrantAllowanceProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowance";
+    value: Uint8Array;
+}
+export type MsgGrantAllowanceEncoded = Omit<MsgGrantAllowance, "allowance"> & {
+    /** allowance can be any of basic, periodic, allowed fee allowance. */ allowance?: BasicAllowanceProtoMsg | PeriodicAllowanceProtoMsg | AllowedMsgAllowanceProtoMsg | AnyProtoMsg | undefined;
+};
+/**
+ * MsgGrantAllowance adds permission for Grantee to spend up to Allowance
+ * of fees from the account of Granter.
+ */
+export interface MsgGrantAllowanceAmino {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee: string;
+    /** allowance can be any of basic, periodic, allowed fee allowance. */
+    allowance?: AnyAmino;
+}
+export interface MsgGrantAllowanceAminoMsg {
+    type: "cosmos-sdk/MsgGrantAllowance";
+    value: MsgGrantAllowanceAmino;
+}
+/** MsgGrantAllowanceResponse defines the Msg/GrantAllowanceResponse response type. */
+export interface MsgGrantAllowanceResponse {
+}
+export interface MsgGrantAllowanceResponseProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgGrantAllowanceResponse";
+    value: Uint8Array;
+}
+/** MsgGrantAllowanceResponse defines the Msg/GrantAllowanceResponse response type. */
+export interface MsgGrantAllowanceResponseAmino {
+}
+export interface MsgGrantAllowanceResponseAminoMsg {
+    type: "cosmos-sdk/MsgGrantAllowanceResponse";
+    value: MsgGrantAllowanceResponseAmino;
+}
+/** MsgRevokeAllowance removes any existing Allowance from Granter to Grantee. */
+export interface MsgRevokeAllowance {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee: string;
+}
+export interface MsgRevokeAllowanceProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowance";
+    value: Uint8Array;
+}
+/** MsgRevokeAllowance removes any existing Allowance from Granter to Grantee. */
+export interface MsgRevokeAllowanceAmino {
+    /** granter is the address of the user granting an allowance of their funds. */
+    granter: string;
+    /** grantee is the address of the user being granted an allowance of another user's funds. */
+    grantee: string;
+}
+export interface MsgRevokeAllowanceAminoMsg {
+    type: "cosmos-sdk/MsgRevokeAllowance";
+    value: MsgRevokeAllowanceAmino;
+}
+/** MsgRevokeAllowanceResponse defines the Msg/RevokeAllowanceResponse response type. */
+export interface MsgRevokeAllowanceResponse {
+}
+export interface MsgRevokeAllowanceResponseProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgRevokeAllowanceResponse";
+    value: Uint8Array;
+}
+/** MsgRevokeAllowanceResponse defines the Msg/RevokeAllowanceResponse response type. */
+export interface MsgRevokeAllowanceResponseAmino {
+}
+export interface MsgRevokeAllowanceResponseAminoMsg {
+    type: "cosmos-sdk/MsgRevokeAllowanceResponse";
+    value: MsgRevokeAllowanceResponseAmino;
+}
+/**
+ * MsgPruneAllowances prunes expired fee allowances.
+ *
+ * Since cosmos-sdk 0.50
+ */
+export interface MsgPruneAllowances {
+    /** pruner is the address of the user pruning expired allowances. */
+    pruner: string;
+}
+export interface MsgPruneAllowancesProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowances";
+    value: Uint8Array;
+}
+/**
+ * MsgPruneAllowances prunes expired fee allowances.
+ *
+ * Since cosmos-sdk 0.50
+ */
+export interface MsgPruneAllowancesAmino {
+    /** pruner is the address of the user pruning expired allowances. */
+    pruner: string;
+}
+export interface MsgPruneAllowancesAminoMsg {
+    type: "cosmos-sdk/MsgPruneAllowances";
+    value: MsgPruneAllowancesAmino;
+}
+/**
+ * MsgPruneAllowancesResponse defines the Msg/PruneAllowancesResponse response type.
+ *
+ * Since cosmos-sdk 0.50
+ */
+export interface MsgPruneAllowancesResponse {
+}
+export interface MsgPruneAllowancesResponseProtoMsg {
+    typeUrl: "/cosmos.feegrant.v1beta1.MsgPruneAllowancesResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgPruneAllowancesResponse defines the Msg/PruneAllowancesResponse response type.
+ *
+ * Since cosmos-sdk 0.50
+ */
+export interface MsgPruneAllowancesResponseAmino {
+}
+export interface MsgPruneAllowancesResponseAminoMsg {
+    type: "cosmos-sdk/MsgPruneAllowancesResponse";
+    value: MsgPruneAllowancesResponseAmino;
+}
+export declare const MsgGrantAllowance: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgGrantAllowance;
+    isAmino(o: any): o is MsgGrantAllowanceAmino;
+    encode(message: MsgGrantAllowance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgGrantAllowance;
+    fromPartial(object: DeepPartial<MsgGrantAllowance>): MsgGrantAllowance;
+    fromAmino(object: MsgGrantAllowanceAmino): MsgGrantAllowance;
+    toAmino(message: MsgGrantAllowance): MsgGrantAllowanceAmino;
+    fromAminoMsg(object: MsgGrantAllowanceAminoMsg): MsgGrantAllowance;
+    toAminoMsg(message: MsgGrantAllowance): MsgGrantAllowanceAminoMsg;
+    fromProtoMsg(message: MsgGrantAllowanceProtoMsg): MsgGrantAllowance;
+    toProto(message: MsgGrantAllowance): Uint8Array;
+    toProtoMsg(message: MsgGrantAllowance): MsgGrantAllowanceProtoMsg;
+};
+export declare const MsgGrantAllowanceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgGrantAllowanceResponse;
+    isAmino(o: any): o is MsgGrantAllowanceResponseAmino;
+    encode(_: MsgGrantAllowanceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgGrantAllowanceResponse;
+    fromPartial(_: DeepPartial<MsgGrantAllowanceResponse>): MsgGrantAllowanceResponse;
+    fromAmino(_: MsgGrantAllowanceResponseAmino): MsgGrantAllowanceResponse;
+    toAmino(_: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAmino;
+    fromAminoMsg(object: MsgGrantAllowanceResponseAminoMsg): MsgGrantAllowanceResponse;
+    toAminoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseAminoMsg;
+    fromProtoMsg(message: MsgGrantAllowanceResponseProtoMsg): MsgGrantAllowanceResponse;
+    toProto(message: MsgGrantAllowanceResponse): Uint8Array;
+    toProtoMsg(message: MsgGrantAllowanceResponse): MsgGrantAllowanceResponseProtoMsg;
+};
+export declare const MsgRevokeAllowance: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgRevokeAllowance;
+    isAmino(o: any): o is MsgRevokeAllowanceAmino;
+    encode(message: MsgRevokeAllowance, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeAllowance;
+    fromPartial(object: DeepPartial<MsgRevokeAllowance>): MsgRevokeAllowance;
+    fromAmino(object: MsgRevokeAllowanceAmino): MsgRevokeAllowance;
+    toAmino(message: MsgRevokeAllowance): MsgRevokeAllowanceAmino;
+    fromAminoMsg(object: MsgRevokeAllowanceAminoMsg): MsgRevokeAllowance;
+    toAminoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceAminoMsg;
+    fromProtoMsg(message: MsgRevokeAllowanceProtoMsg): MsgRevokeAllowance;
+    toProto(message: MsgRevokeAllowance): Uint8Array;
+    toProtoMsg(message: MsgRevokeAllowance): MsgRevokeAllowanceProtoMsg;
+};
+export declare const MsgRevokeAllowanceResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgRevokeAllowanceResponse;
+    isAmino(o: any): o is MsgRevokeAllowanceResponseAmino;
+    encode(_: MsgRevokeAllowanceResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgRevokeAllowanceResponse;
+    fromPartial(_: DeepPartial<MsgRevokeAllowanceResponse>): MsgRevokeAllowanceResponse;
+    fromAmino(_: MsgRevokeAllowanceResponseAmino): MsgRevokeAllowanceResponse;
+    toAmino(_: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAmino;
+    fromAminoMsg(object: MsgRevokeAllowanceResponseAminoMsg): MsgRevokeAllowanceResponse;
+    toAminoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseAminoMsg;
+    fromProtoMsg(message: MsgRevokeAllowanceResponseProtoMsg): MsgRevokeAllowanceResponse;
+    toProto(message: MsgRevokeAllowanceResponse): Uint8Array;
+    toProtoMsg(message: MsgRevokeAllowanceResponse): MsgRevokeAllowanceResponseProtoMsg;
+};
+export declare const MsgPruneAllowances: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgPruneAllowances;
+    isAmino(o: any): o is MsgPruneAllowancesAmino;
+    encode(message: MsgPruneAllowances, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgPruneAllowances;
+    fromPartial(object: DeepPartial<MsgPruneAllowances>): MsgPruneAllowances;
+    fromAmino(object: MsgPruneAllowancesAmino): MsgPruneAllowances;
+    toAmino(message: MsgPruneAllowances): MsgPruneAllowancesAmino;
+    fromAminoMsg(object: MsgPruneAllowancesAminoMsg): MsgPruneAllowances;
+    toAminoMsg(message: MsgPruneAllowances): MsgPruneAllowancesAminoMsg;
+    fromProtoMsg(message: MsgPruneAllowancesProtoMsg): MsgPruneAllowances;
+    toProto(message: MsgPruneAllowances): Uint8Array;
+    toProtoMsg(message: MsgPruneAllowances): MsgPruneAllowancesProtoMsg;
+};
+export declare const MsgPruneAllowancesResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgPruneAllowancesResponse;
+    isAmino(o: any): o is MsgPruneAllowancesResponseAmino;
+    encode(_: MsgPruneAllowancesResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgPruneAllowancesResponse;
+    fromPartial(_: DeepPartial<MsgPruneAllowancesResponse>): MsgPruneAllowancesResponse;
+    fromAmino(_: MsgPruneAllowancesResponseAmino): MsgPruneAllowancesResponse;
+    toAmino(_: MsgPruneAllowancesResponse): MsgPruneAllowancesResponseAmino;
+    fromAminoMsg(object: MsgPruneAllowancesResponseAminoMsg): MsgPruneAllowancesResponse;
+    toAminoMsg(message: MsgPruneAllowancesResponse): MsgPruneAllowancesResponseAminoMsg;
+    fromProtoMsg(message: MsgPruneAllowancesResponseProtoMsg): MsgPruneAllowancesResponse;
+    toProto(message: MsgPruneAllowancesResponse): Uint8Array;
+    toProtoMsg(message: MsgPruneAllowancesResponse): MsgPruneAllowancesResponseProtoMsg;
+};

package/dist/cosmos/feegrant/v1beta1/tx.registry.d.ts

@@ -0,0 +1,2 @@
+import { TelescopeGeneratedType } from "../../../types";
+export declare const registry: ReadonlyArray<[string, TelescopeGeneratedType<any, any, any>]>;

package/dist/cosmos/feegrant/v1beta1/tx.registry.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registry = void 0;
+const tx_1 = require("./tx");
+exports.registry = [["/cosmos.feegrant.v1beta1.MsgGrantAllowance", tx_1.MsgGrantAllowance], ["/cosmos.feegrant.v1beta1.MsgRevokeAllowance", tx_1.MsgRevokeAllowance], ["/cosmos.feegrant.v1beta1.MsgPruneAllowances", tx_1.MsgPruneAllowances]];

package/dist/cosmos/feegrant/v1beta1/tx.rpc.msg.d.ts

@@ -0,0 +1,29 @@
+import { TxRpc } from "../../../types";
+import { MsgGrantAllowance, MsgGrantAllowanceResponse, MsgRevokeAllowance, MsgRevokeAllowanceResponse, MsgPruneAllowances, MsgPruneAllowancesResponse } from "./tx";
+/** Msg defines the feegrant msg service. */
+export interface Msg {
+    /**
+     * GrantAllowance grants fee allowance to the grantee on the granter's
+     * account with the provided expiration time.
+     */
+    grantAllowance(request: MsgGrantAllowance): Promise<MsgGrantAllowanceResponse>;
+    /**
+     * RevokeAllowance revokes any fee allowance of granter's account that
+     * has been granted to the grantee.
+     */
+    revokeAllowance(request: MsgRevokeAllowance): Promise<MsgRevokeAllowanceResponse>;
+    /**
+     * PruneAllowances prunes expired fee allowances, currently up to 75 at a time.
+     *
+     * Since cosmos-sdk 0.50
+     */
+    pruneAllowances(request: MsgPruneAllowances): Promise<MsgPruneAllowancesResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    grantAllowance: (request: MsgGrantAllowance) => Promise<MsgGrantAllowanceResponse>;
+    revokeAllowance: (request: MsgRevokeAllowance) => Promise<MsgRevokeAllowanceResponse>;
+    pruneAllowances: (request: MsgPruneAllowances) => Promise<MsgPruneAllowancesResponse>;
+}
+export declare const createClientImpl: (rpc: TxRpc) => MsgClientImpl;

package/dist/cosmos/feegrant/v1beta1/tx.rpc.msg.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClientImpl = exports.MsgClientImpl = void 0;
+const binary_1 = require("../../../binary");
+const tx_1 = require("./tx");
+class MsgClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* GrantAllowance grants fee allowance to the grantee on the granter's
+     account with the provided expiration time. */
+    grantAllowance = async (request) => {
+        const data = tx_1.MsgGrantAllowance.encode(request).finish();
+        const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "GrantAllowance", data);
+        return promise.then(data => tx_1.MsgGrantAllowanceResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* RevokeAllowance revokes any fee allowance of granter's account that
+     has been granted to the grantee. */
+    revokeAllowance = async (request) => {
+        const data = tx_1.MsgRevokeAllowance.encode(request).finish();
+        const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "RevokeAllowance", data);
+        return promise.then(data => tx_1.MsgRevokeAllowanceResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* PruneAllowances prunes expired fee allowances, currently up to 75 at a time.
+    
+     Since cosmos-sdk 0.50 */
+    pruneAllowances = async (request) => {
+        const data = tx_1.MsgPruneAllowances.encode(request).finish();
+        const promise = this.rpc.request("cosmos.feegrant.v1beta1.Msg", "PruneAllowances", data);
+        return promise.then(data => tx_1.MsgPruneAllowancesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.MsgClientImpl = MsgClientImpl;
+const createClientImpl = (rpc) => {
+    return new MsgClientImpl(rpc);
+};
+exports.createClientImpl = createClientImpl;

package/dist/cosmos/genutil/module/v1/module.d.ts

@@ -0,0 +1,32 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object for the genutil module. */
+export interface Module {
+}
+export interface ModuleProtoMsg {
+    typeUrl: "/cosmos.genutil.module.v1.Module";
+    value: Uint8Array;
+}
+/** Module is the config object for the genutil module. */
+export interface ModuleAmino {
+}
+export interface ModuleAminoMsg {
+    type: "cosmos-sdk/Module";
+    value: ModuleAmino;
+}
+export declare const Module: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Module;
+    isAmino(o: any): o is ModuleAmino;
+    encode(_: Module, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Module;
+    fromPartial(_: DeepPartial<Module>): Module;
+    fromAmino(_: ModuleAmino): Module;
+    toAmino(_: Module): ModuleAmino;
+    fromAminoMsg(object: ModuleAminoMsg): Module;
+    toAminoMsg(message: Module): ModuleAminoMsg;
+    fromProtoMsg(message: ModuleProtoMsg): Module;
+    toProto(message: Module): Uint8Array;
+    toProtoMsg(message: Module): ModuleProtoMsg;
+};

package/dist/cosmos/genutil/module/v1/module.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+function createBaseModule() {
+    return {};
+}
+exports.Module = {
+    typeUrl: "/cosmos.genutil.module.v1.Module",
+    aminoType: "cosmos-sdk/Module",
+    is(o) {
+        return o && o.$typeUrl === exports.Module.typeUrl;
+    },
+    isAmino(o) {
+        return o && o.$typeUrl === exports.Module.typeUrl;
+    },
+    encode(_, writer = binary_1.BinaryWriter.create()) {
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseModule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(_) {
+        const message = createBaseModule();
+        return message;
+    },
+    fromAmino(_) {
+        const message = createBaseModule();
+        return message;
+    },
+    toAmino(_) {
+        const obj = {};
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Module.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Module",
+            value: exports.Module.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Module.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Module.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.genutil.module.v1.Module",
+            value: exports.Module.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Module.typeUrl, exports.Module);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Module.aminoType, exports.Module.typeUrl);

package/dist/cosmos/genutil/v1beta1/genesis.d.ts

@@ -0,0 +1,36 @@
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/** GenesisState defines the raw genesis transaction in JSON. */
+export interface GenesisState {
+    /** gen_txs defines the genesis transactions. */
+    genTxs: Uint8Array[];
+}
+export interface GenesisStateProtoMsg {
+    typeUrl: "/cosmos.genutil.v1beta1.GenesisState";
+    value: Uint8Array;
+}
+/** GenesisState defines the raw genesis transaction in JSON. */
+export interface GenesisStateAmino {
+    /** gen_txs defines the genesis transactions. */
+    gen_txs: string[];
+}
+export interface GenesisStateAminoMsg {
+    type: "cosmos-sdk/GenesisState";
+    value: GenesisStateAmino;
+}
+export declare const GenesisState: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is GenesisState;
+    isAmino(o: any): o is GenesisStateAmino;
+    encode(message: GenesisState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): GenesisState;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+    fromAmino(object: GenesisStateAmino): GenesisState;
+    toAmino(message: GenesisState): GenesisStateAmino;
+    fromAminoMsg(object: GenesisStateAminoMsg): GenesisState;
+    toAminoMsg(message: GenesisState): GenesisStateAminoMsg;
+    fromProtoMsg(message: GenesisStateProtoMsg): GenesisState;
+    toProto(message: GenesisState): Uint8Array;
+    toProtoMsg(message: GenesisState): GenesisStateProtoMsg;
+};

package/dist/cosmos/genutil/v1beta1/genesis.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenesisState = void 0;
+const binary_1 = require("../../../binary");
+const helpers_1 = require("../../../helpers");
+const registry_1 = require("../../../registry");
+function createBaseGenesisState() {
+    return {
+        genTxs: []
+    };
+}
+exports.GenesisState = {
+    typeUrl: "/cosmos.genutil.v1beta1.GenesisState",
+    aminoType: "cosmos-sdk/GenesisState",
+    is(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.genTxs) && (!o.genTxs.length || o.genTxs[0] instanceof Uint8Array || typeof o.genTxs[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.GenesisState.typeUrl || Array.isArray(o.gen_txs) && (!o.gen_txs.length || o.gen_txs[0] instanceof Uint8Array || typeof o.gen_txs[0] === "string"));
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        for (const v of message.genTxs) {
+            writer.uint32(10).bytes(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGenesisState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.genTxs.push(reader.bytes());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseGenesisState();
+        message.genTxs = object.genTxs?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseGenesisState();
+        message.genTxs = object.gen_txs?.map(e => (0, helpers_1.bytesFromBase64)(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.genTxs) {
+            obj.gen_txs = message.genTxs.map(e => (0, helpers_1.base64FromBytes)(e));
+        }
+        else {
+            obj.gen_txs = message.genTxs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.GenesisState.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/GenesisState",
+            value: exports.GenesisState.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.GenesisState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.GenesisState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/cosmos.genutil.v1beta1.GenesisState",
+            value: exports.GenesisState.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.GenesisState.typeUrl, exports.GenesisState);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.GenesisState.aminoType, exports.GenesisState.typeUrl);

package/dist/cosmos/gov/module/v1/module.d.ts

@@ -0,0 +1,46 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/** Module is the config object of the gov module. */
+export interface Module {
+    /**
+     * max_metadata_len defines the maximum proposal metadata length.
+     * Defaults to 255 if not explicitly set.
+     */
+    maxMetadataLen: bigint;
+    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    authority: string;
+}
+export interface ModuleProtoMsg {
+    typeUrl: "/cosmos.gov.module.v1.Module";
+    value: Uint8Array;
+}
+/** Module is the config object of the gov module. */
+export interface ModuleAmino {
+    /**
+     * max_metadata_len defines the maximum proposal metadata length.
+     * Defaults to 255 if not explicitly set.
+     */
+    max_metadata_len: string;
+    /** authority defines the custom module authority. If not set, defaults to the governance module. */
+    authority: string;
+}
+export interface ModuleAminoMsg {
+    type: "cosmos-sdk/Module";
+    value: ModuleAmino;
+}
+export declare const Module: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Module;
+    isAmino(o: any): o is ModuleAmino;
+    encode(message: Module, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Module;
+    fromPartial(object: DeepPartial<Module>): Module;
+    fromAmino(object: ModuleAmino): Module;
+    toAmino(message: Module): ModuleAmino;
+    fromAminoMsg(object: ModuleAminoMsg): Module;
+    toAminoMsg(message: Module): ModuleAminoMsg;
+    fromProtoMsg(message: ModuleProtoMsg): Module;
+    toProto(message: Module): Uint8Array;
+    toProtoMsg(message: Module): ModuleProtoMsg;
+};