@xpla/xpla-react 1.7.0-beta.0 → 1.7.0-beta.10

package/ibc/applications/transfer/v1/query.rpc.func.d.ts

@@ -0,0 +1,14 @@
+import { RpcResolver } from "../../../../helper-func-types";
+import { QueryDenomTracesRequest, QueryDenomTracesResponse, QueryDenomTraceRequest, QueryDenomTraceResponse, QueryParamsRequest, QueryParamsResponse, QueryDenomHashRequest, QueryDenomHashResponse, QueryEscrowAddressRequest, QueryEscrowAddressResponse, QueryTotalEscrowForDenomRequest, QueryTotalEscrowForDenomResponse } from "./query";
+export declare const createGetDenomTraces: (clientResolver?: RpcResolver) => (request: QueryDenomTracesRequest) => Promise<QueryDenomTracesResponse>;
+export declare const useGetDenomTraces: <TData = QueryDenomTracesResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryDenomTracesRequest, QueryDenomTracesResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetDenomTrace: (clientResolver?: RpcResolver) => (request: QueryDenomTraceRequest) => Promise<QueryDenomTraceResponse>;
+export declare const useGetDenomTrace: <TData = QueryDenomTraceResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryDenomTraceRequest, QueryDenomTraceResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetParams: (clientResolver?: RpcResolver) => (request: QueryParamsRequest) => Promise<QueryParamsResponse>;
+export declare const useGetParams: <TData = QueryParamsResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryParamsRequest, QueryParamsResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetDenomHash: (clientResolver?: RpcResolver) => (request: QueryDenomHashRequest) => Promise<QueryDenomHashResponse>;
+export declare const useGetDenomHash: <TData = QueryDenomHashResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryDenomHashRequest, QueryDenomHashResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetEscrowAddress: (clientResolver?: RpcResolver) => (request: QueryEscrowAddressRequest) => Promise<QueryEscrowAddressResponse>;
+export declare const useGetEscrowAddress: <TData = QueryEscrowAddressResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryEscrowAddressRequest, QueryEscrowAddressResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;
+export declare const createGetTotalEscrowForDenom: (clientResolver?: RpcResolver) => (request: QueryTotalEscrowForDenomRequest) => Promise<QueryTotalEscrowForDenomResponse>;
+export declare const useGetTotalEscrowForDenom: <TData = QueryTotalEscrowForDenomResponse>({ request, options, clientResolver, customizedQueryKey, }: import("../../../../react-query").UseQueryParams<QueryTotalEscrowForDenomRequest, QueryTotalEscrowForDenomResponse, TData>) => import("@tanstack/react-query").UseQueryResult<TData, Error>;

package/ibc/applications/transfer/v1/query.rpc.func.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetTotalEscrowForDenom = exports.createGetTotalEscrowForDenom = exports.useGetEscrowAddress = exports.createGetEscrowAddress = exports.useGetDenomHash = exports.createGetDenomHash = exports.useGetParams = exports.createGetParams = exports.useGetDenomTrace = exports.createGetDenomTrace = exports.useGetDenomTraces = exports.createGetDenomTraces = void 0;
+const helper_func_types_1 = require("../../../../helper-func-types");
+const react_query_1 = require("../../../../react-query");
+const query_1 = require("./query");
+const createGetDenomTraces = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryDenomTracesRequest.encode,
+    decode: query_1.QueryDenomTracesResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "DenomTraces",
+    clientResolver
+});
+exports.createGetDenomTraces = createGetDenomTraces;
+exports.useGetDenomTraces = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetDenomTraces,
+    queryKeyPrefix: "DenomTracesQuery"
+});
+const createGetDenomTrace = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryDenomTraceRequest.encode,
+    decode: query_1.QueryDenomTraceResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "DenomTrace",
+    clientResolver
+});
+exports.createGetDenomTrace = createGetDenomTrace;
+exports.useGetDenomTrace = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetDenomTrace,
+    queryKeyPrefix: "DenomTraceQuery"
+});
+const createGetParams = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryParamsRequest.encode,
+    decode: query_1.QueryParamsResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "Params",
+    clientResolver
+});
+exports.createGetParams = createGetParams;
+exports.useGetParams = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetParams,
+    queryKeyPrefix: "ParamsQuery"
+});
+const createGetDenomHash = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryDenomHashRequest.encode,
+    decode: query_1.QueryDenomHashResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "DenomHash",
+    clientResolver
+});
+exports.createGetDenomHash = createGetDenomHash;
+exports.useGetDenomHash = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetDenomHash,
+    queryKeyPrefix: "DenomHashQuery"
+});
+const createGetEscrowAddress = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryEscrowAddressRequest.encode,
+    decode: query_1.QueryEscrowAddressResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "EscrowAddress",
+    clientResolver
+});
+exports.createGetEscrowAddress = createGetEscrowAddress;
+exports.useGetEscrowAddress = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetEscrowAddress,
+    queryKeyPrefix: "EscrowAddressQuery"
+});
+const createGetTotalEscrowForDenom = (clientResolver) => (0, helper_func_types_1.buildQuery)({
+    encode: query_1.QueryTotalEscrowForDenomRequest.encode,
+    decode: query_1.QueryTotalEscrowForDenomResponse.decode,
+    service: "ibc.applications.transfer.v1.Query",
+    method: "TotalEscrowForDenom",
+    clientResolver
+});
+exports.createGetTotalEscrowForDenom = createGetTotalEscrowForDenom;
+exports.useGetTotalEscrowForDenom = (0, react_query_1.buildUseQuery)({
+    builderQueryFn: exports.createGetTotalEscrowForDenom,
+    queryKeyPrefix: "TotalEscrowForDenomQuery"
+});

package/ibc/applications/transfer/v1/transfer.d.ts

@@ -0,0 +1,112 @@
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+export interface DenomTrace {
+    /**
+     * path defines the chain of port/channel identifiers used for tracing the
+     * source of the fungible token.
+     */
+    path: string;
+    /** base denomination of the relayed fungible token. */
+    baseDenom: string;
+}
+export interface DenomTraceProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.DenomTrace";
+    value: Uint8Array;
+}
+/**
+ * DenomTrace contains the base denomination for ICS20 fungible tokens and the
+ * source tracing information path.
+ */
+export interface DenomTraceAmino {
+    /**
+     * path defines the chain of port/channel identifiers used for tracing the
+     * source of the fungible token.
+     */
+    path: string;
+    /** base denomination of the relayed fungible token. */
+    base_denom: string;
+}
+export interface DenomTraceAminoMsg {
+    type: "cosmos-sdk/DenomTrace";
+    value: DenomTraceAmino;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+export interface Params {
+    /**
+     * send_enabled enables or disables all cross-chain token transfers from this
+     * chain.
+     */
+    sendEnabled: boolean;
+    /**
+     * receive_enabled enables or disables all cross-chain token transfers to this
+     * chain.
+     */
+    receiveEnabled: boolean;
+}
+export interface ParamsProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.Params";
+    value: Uint8Array;
+}
+/**
+ * Params defines the set of IBC transfer parameters.
+ * NOTE: To prevent a single token from being transferred, set the
+ * TransfersEnabled parameter to true and then set the bank module's SendEnabled
+ * parameter for the denomination to false.
+ */
+export interface ParamsAmino {
+    /**
+     * send_enabled enables or disables all cross-chain token transfers from this
+     * chain.
+     */
+    send_enabled: boolean;
+    /**
+     * receive_enabled enables or disables all cross-chain token transfers to this
+     * chain.
+     */
+    receive_enabled: boolean;
+}
+export interface ParamsAminoMsg {
+    type: "cosmos-sdk/Params";
+    value: ParamsAmino;
+}
+export declare const DenomTrace: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is DenomTrace;
+    isAmino(o: any): o is DenomTraceAmino;
+    encode(message: DenomTrace, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): DenomTrace;
+    fromPartial(object: DeepPartial<DenomTrace>): DenomTrace;
+    fromAmino(object: DenomTraceAmino): DenomTrace;
+    toAmino(message: DenomTrace): DenomTraceAmino;
+    fromAminoMsg(object: DenomTraceAminoMsg): DenomTrace;
+    toAminoMsg(message: DenomTrace): DenomTraceAminoMsg;
+    fromProtoMsg(message: DenomTraceProtoMsg): DenomTrace;
+    toProto(message: DenomTrace): Uint8Array;
+    toProtoMsg(message: DenomTrace): DenomTraceProtoMsg;
+};
+export declare const Params: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is Params;
+    isAmino(o: any): o is ParamsAmino;
+    encode(message: Params, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Params;
+    fromPartial(object: DeepPartial<Params>): 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;
+};

package/ibc/applications/transfer/v1/transfer.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Params = exports.DenomTrace = void 0;
+const binary_1 = require("../../../../binary");
+const registry_1 = require("../../../../registry");
+function createBaseDenomTrace() {
+    return {
+        path: "",
+        baseDenom: ""
+    };
+}
+exports.DenomTrace = {
+    typeUrl: "/ibc.applications.transfer.v1.DenomTrace",
+    aminoType: "cosmos-sdk/DenomTrace",
+    is(o) {
+        return o && (o.$typeUrl === exports.DenomTrace.typeUrl || typeof o.path === "string" && typeof o.baseDenom === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.DenomTrace.typeUrl || typeof o.path === "string" && typeof o.base_denom === "string");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.path !== "") {
+            writer.uint32(10).string(message.path);
+        }
+        if (message.baseDenom !== "") {
+            writer.uint32(18).string(message.baseDenom);
+        }
+        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 = createBaseDenomTrace();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.path = reader.string();
+                    break;
+                case 2:
+                    message.baseDenom = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseDenomTrace();
+        message.path = object.path ?? "";
+        message.baseDenom = object.baseDenom ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseDenomTrace();
+        if (object.path !== undefined && object.path !== null) {
+            message.path = object.path;
+        }
+        if (object.base_denom !== undefined && object.base_denom !== null) {
+            message.baseDenom = object.base_denom;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.path = message.path === "" ? undefined : message.path;
+        obj.base_denom = message.baseDenom === "" ? undefined : message.baseDenom;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.DenomTrace.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/DenomTrace",
+            value: exports.DenomTrace.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.DenomTrace.decode(message.value);
+    },
+    toProto(message) {
+        return exports.DenomTrace.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.transfer.v1.DenomTrace",
+            value: exports.DenomTrace.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.DenomTrace.typeUrl, exports.DenomTrace);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.DenomTrace.aminoType, exports.DenomTrace.typeUrl);
+function createBaseParams() {
+    return {
+        sendEnabled: false,
+        receiveEnabled: false
+    };
+}
+exports.Params = {
+    typeUrl: "/ibc.applications.transfer.v1.Params",
+    aminoType: "cosmos-sdk/Params",
+    is(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.sendEnabled === "boolean" && typeof o.receiveEnabled === "boolean");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === exports.Params.typeUrl || typeof o.send_enabled === "boolean" && typeof o.receive_enabled === "boolean");
+    },
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.sendEnabled === true) {
+            writer.uint32(8).bool(message.sendEnabled);
+        }
+        if (message.receiveEnabled === true) {
+            writer.uint32(16).bool(message.receiveEnabled);
+        }
+        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 = createBaseParams();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sendEnabled = reader.bool();
+                    break;
+                case 2:
+                    message.receiveEnabled = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseParams();
+        message.sendEnabled = object.sendEnabled ?? false;
+        message.receiveEnabled = object.receiveEnabled ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseParams();
+        if (object.send_enabled !== undefined && object.send_enabled !== null) {
+            message.sendEnabled = object.send_enabled;
+        }
+        if (object.receive_enabled !== undefined && object.receive_enabled !== null) {
+            message.receiveEnabled = object.receive_enabled;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.send_enabled = message.sendEnabled === false ? undefined : message.sendEnabled;
+        obj.receive_enabled = message.receiveEnabled === false ? undefined : message.receiveEnabled;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Params.fromAmino(object.value);
+    },
+    toAminoMsg(message) {
+        return {
+            type: "cosmos-sdk/Params",
+            value: exports.Params.toAmino(message)
+        };
+    },
+    fromProtoMsg(message) {
+        return exports.Params.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Params.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/ibc.applications.transfer.v1.Params",
+            value: exports.Params.encode(message).finish()
+        };
+    }
+};
+registry_1.GlobalDecoderRegistry.register(exports.Params.typeUrl, exports.Params);
+registry_1.GlobalDecoderRegistry.registerAminoProtoMapping(exports.Params.aminoType, exports.Params.typeUrl);

package/ibc/applications/transfer/v1/tx.d.ts

@@ -0,0 +1,202 @@
+import { Coin, CoinAmino } from "../../../../cosmos/base/v1beta1/coin";
+import { Height, HeightAmino, Params, ParamsAmino } from "../../../core/client/v1/client";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
+ * ICS20 enabled chains. See ICS Spec here:
+ * https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
+ */
+export interface MsgTransfer {
+    /** the port on which the packet will be sent */
+    sourcePort: string;
+    /** the channel by which the packet will be sent */
+    sourceChannel: string;
+    /** the tokens to be transferred */
+    token: Coin;
+    /** the sender address */
+    sender: string;
+    /** the recipient address on the destination chain */
+    receiver: string;
+    /**
+     * Timeout height relative to the current block height.
+     * The timeout is disabled when set to 0.
+     */
+    timeoutHeight: Height;
+    /**
+     * Timeout timestamp in absolute nanoseconds since unix epoch.
+     * The timeout is disabled when set to 0.
+     */
+    timeoutTimestamp: bigint;
+    /** optional memo */
+    memo: string;
+}
+export interface MsgTransferProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.MsgTransfer";
+    value: Uint8Array;
+}
+/**
+ * MsgTransfer defines a msg to transfer fungible tokens (i.e Coins) between
+ * ICS20 enabled chains. See ICS Spec here:
+ * https://github.com/cosmos/ibc/tree/master/spec/app/ics-020-fungible-token-transfer#data-structures
+ */
+export interface MsgTransferAmino {
+    /** the port on which the packet will be sent */
+    source_port: string;
+    /** the channel by which the packet will be sent */
+    source_channel: string;
+    /** the tokens to be transferred */
+    token: CoinAmino;
+    /** the sender address */
+    sender: string;
+    /** the recipient address on the destination chain */
+    receiver: string;
+    /**
+     * Timeout height relative to the current block height.
+     * The timeout is disabled when set to 0.
+     */
+    timeout_height: HeightAmino;
+    /**
+     * Timeout timestamp in absolute nanoseconds since unix epoch.
+     * The timeout is disabled when set to 0.
+     */
+    timeout_timestamp: string;
+    /** optional memo */
+    memo: string;
+}
+export interface MsgTransferAminoMsg {
+    type: "cosmos-sdk/MsgTransfer";
+    value: MsgTransferAmino;
+}
+/** MsgTransferResponse defines the Msg/Transfer response type. */
+export interface MsgTransferResponse {
+    /** sequence number of the transfer packet sent */
+    sequence: bigint;
+}
+export interface MsgTransferResponseProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.MsgTransferResponse";
+    value: Uint8Array;
+}
+/** MsgTransferResponse defines the Msg/Transfer response type. */
+export interface MsgTransferResponseAmino {
+    /** sequence number of the transfer packet sent */
+    sequence: string;
+}
+export interface MsgTransferResponseAminoMsg {
+    type: "cosmos-sdk/MsgTransferResponse";
+    value: MsgTransferResponseAmino;
+}
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+export interface MsgUpdateParams {
+    /** signer address */
+    signer: string;
+    /**
+     * params defines the transfer parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: Params;
+}
+export interface MsgUpdateParamsProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParams";
+    value: Uint8Array;
+}
+/** MsgUpdateParams is the Msg/UpdateParams request type. */
+export interface MsgUpdateParamsAmino {
+    /** signer address */
+    signer: string;
+    /**
+     * params defines the transfer parameters to update.
+     *
+     * NOTE: All parameters must be supplied.
+     */
+    params: ParamsAmino;
+}
+export interface MsgUpdateParamsAminoMsg {
+    type: "cosmos-sdk/MsgUpdateParams";
+    value: MsgUpdateParamsAmino;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponse {
+}
+export interface MsgUpdateParamsResponseProtoMsg {
+    typeUrl: "/ibc.applications.transfer.v1.MsgUpdateParamsResponse";
+    value: Uint8Array;
+}
+/**
+ * MsgUpdateParamsResponse defines the response structure for executing a
+ * MsgUpdateParams message.
+ */
+export interface MsgUpdateParamsResponseAmino {
+}
+export interface MsgUpdateParamsResponseAminoMsg {
+    type: "cosmos-sdk/MsgUpdateParamsResponse";
+    value: MsgUpdateParamsResponseAmino;
+}
+export declare const MsgTransfer: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgTransfer;
+    isAmino(o: any): o is MsgTransferAmino;
+    encode(message: MsgTransfer, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgTransfer;
+    fromPartial(object: DeepPartial<MsgTransfer>): MsgTransfer;
+    fromAmino(object: MsgTransferAmino): MsgTransfer;
+    toAmino(message: MsgTransfer): MsgTransferAmino;
+    fromAminoMsg(object: MsgTransferAminoMsg): MsgTransfer;
+    toAminoMsg(message: MsgTransfer): MsgTransferAminoMsg;
+    fromProtoMsg(message: MsgTransferProtoMsg): MsgTransfer;
+    toProto(message: MsgTransfer): Uint8Array;
+    toProtoMsg(message: MsgTransfer): MsgTransferProtoMsg;
+};
+export declare const MsgTransferResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgTransferResponse;
+    isAmino(o: any): o is MsgTransferResponseAmino;
+    encode(message: MsgTransferResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgTransferResponse;
+    fromPartial(object: DeepPartial<MsgTransferResponse>): MsgTransferResponse;
+    fromAmino(object: MsgTransferResponseAmino): MsgTransferResponse;
+    toAmino(message: MsgTransferResponse): MsgTransferResponseAmino;
+    fromAminoMsg(object: MsgTransferResponseAminoMsg): MsgTransferResponse;
+    toAminoMsg(message: MsgTransferResponse): MsgTransferResponseAminoMsg;
+    fromProtoMsg(message: MsgTransferResponseProtoMsg): MsgTransferResponse;
+    toProto(message: MsgTransferResponse): Uint8Array;
+    toProtoMsg(message: MsgTransferResponse): MsgTransferResponseProtoMsg;
+};
+export declare const MsgUpdateParams: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParams;
+    isAmino(o: any): o is MsgUpdateParamsAmino;
+    encode(message: MsgUpdateParams, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParams;
+    fromPartial(object: DeepPartial<MsgUpdateParams>): MsgUpdateParams;
+    fromAmino(object: MsgUpdateParamsAmino): MsgUpdateParams;
+    toAmino(message: MsgUpdateParams): MsgUpdateParamsAmino;
+    fromAminoMsg(object: MsgUpdateParamsAminoMsg): MsgUpdateParams;
+    toAminoMsg(message: MsgUpdateParams): MsgUpdateParamsAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsProtoMsg): MsgUpdateParams;
+    toProto(message: MsgUpdateParams): Uint8Array;
+    toProtoMsg(message: MsgUpdateParams): MsgUpdateParamsProtoMsg;
+};
+export declare const MsgUpdateParamsResponse: {
+    typeUrl: string;
+    aminoType: string;
+    is(o: any): o is MsgUpdateParamsResponse;
+    isAmino(o: any): o is MsgUpdateParamsResponseAmino;
+    encode(_: MsgUpdateParamsResponse, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateParamsResponse;
+    fromPartial(_: DeepPartial<MsgUpdateParamsResponse>): MsgUpdateParamsResponse;
+    fromAmino(_: MsgUpdateParamsResponseAmino): MsgUpdateParamsResponse;
+    toAmino(_: MsgUpdateParamsResponse): MsgUpdateParamsResponseAmino;
+    fromAminoMsg(object: MsgUpdateParamsResponseAminoMsg): MsgUpdateParamsResponse;
+    toAminoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseAminoMsg;
+    fromProtoMsg(message: MsgUpdateParamsResponseProtoMsg): MsgUpdateParamsResponse;
+    toProto(message: MsgUpdateParamsResponse): Uint8Array;
+    toProtoMsg(message: MsgUpdateParamsResponse): MsgUpdateParamsResponseProtoMsg;
+};