@sparkdreamnft/sparkdreamjs 0.0.6 → 0.0.8

package/ibc/applications/rate_limiting/v1/query.lcd.d.ts

@@ -0,0 +1,14 @@
+import { LCDClient } from "@cosmology/lcd";
+import { QueryAllRateLimitsRequest, QueryAllRateLimitsResponse, QueryRateLimitRequest, QueryRateLimitResponse, QueryRateLimitsByChainIDRequest, QueryRateLimitsByChainIDResponse, QueryRateLimitsByChannelOrClientIDRequest, QueryRateLimitsByChannelOrClientIDResponse, QueryAllBlacklistedDenomsRequest, QueryAllBlacklistedDenomsResponse, QueryAllWhitelistedAddressesRequest, QueryAllWhitelistedAddressesResponse } from "./query";
+export declare class LCDQueryClient {
+    req: LCDClient;
+    constructor({ requestClient }: {
+        requestClient: LCDClient;
+    });
+    allRateLimits: (_params?: QueryAllRateLimitsRequest) => Promise<QueryAllRateLimitsResponse>;
+    rateLimit: (params: QueryRateLimitRequest) => Promise<QueryRateLimitResponse>;
+    rateLimitsByChainID: (params: QueryRateLimitsByChainIDRequest) => Promise<QueryRateLimitsByChainIDResponse>;
+    rateLimitsByChannelOrClientID: (params: QueryRateLimitsByChannelOrClientIDRequest) => Promise<QueryRateLimitsByChannelOrClientIDResponse>;
+    allBlacklistedDenoms: (_params?: QueryAllBlacklistedDenomsRequest) => Promise<QueryAllBlacklistedDenomsResponse>;
+    allWhitelistedAddresses: (_params?: QueryAllWhitelistedAddressesRequest) => Promise<QueryAllWhitelistedAddressesResponse>;
+}

package/ibc/applications/rate_limiting/v1/query.lcd.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LCDQueryClient = void 0;
+class LCDQueryClient {
+    req;
+    constructor({ requestClient }) {
+        this.req = requestClient;
+    }
+    /* Queries all rate limits */
+    allRateLimits = async (_params = {}) => {
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimits`;
+        return await this.req.get(endpoint);
+    };
+    /* Queries a specific rate limit by channel ID and denom
+     Ex:
+      - /ratelimit/{channel_or_client_id}/by_denom?denom={denom} */
+    rateLimit = async (params) => {
+        const options = {
+            params: {}
+        };
+        if (typeof params?.denom !== "undefined") {
+            options.params.denom = params.denom;
+        }
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimit/ratelimit/${params.channelOrClientId}/by_denom`;
+        return await this.req.get(endpoint, options);
+    };
+    /* Queries all the rate limits for a given chain */
+    rateLimitsByChainID = async (params) => {
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimit/ratelimits/${params.chainId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Queries all the rate limits for a given channel ID */
+    rateLimitsByChannelOrClientID = async (params) => {
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimit/ratelimits/${params.channelOrClientId}`;
+        return await this.req.get(endpoint);
+    };
+    /* Queries all blacklisted denoms */
+    allBlacklistedDenoms = async (_params = {}) => {
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimit/blacklisted_denoms`;
+        return await this.req.get(endpoint);
+    };
+    /* Queries all whitelisted address pairs */
+    allWhitelistedAddresses = async (_params = {}) => {
+        const endpoint = `ibc/apps/rate-limiting/v1/ratelimit/whitelisted_addresses`;
+        return await this.req.get(endpoint);
+    };
+}
+exports.LCDQueryClient = LCDQueryClient;

package/ibc/applications/rate_limiting/v1/query.rpc.Query.d.ts

@@ -0,0 +1,40 @@
+import { TxRpc } from "../../../../types";
+import { QueryClient } from "@cosmjs/stargate";
+import { QueryAllRateLimitsRequest, QueryAllRateLimitsResponse, QueryRateLimitRequest, QueryRateLimitResponse, QueryRateLimitsByChainIDRequest, QueryRateLimitsByChainIDResponse, QueryRateLimitsByChannelOrClientIDRequest, QueryRateLimitsByChannelOrClientIDResponse, QueryAllBlacklistedDenomsRequest, QueryAllBlacklistedDenomsResponse, QueryAllWhitelistedAddressesRequest, QueryAllWhitelistedAddressesResponse } from "./query";
+/** Query defines the gRPC querier service. */
+export interface Query {
+    /** Queries all rate limits */
+    allRateLimits(request?: QueryAllRateLimitsRequest): Promise<QueryAllRateLimitsResponse>;
+    /**
+     * Queries a specific rate limit by channel ID and denom
+     * Ex:
+     *  - /ratelimit/{channel_or_client_id}/by_denom?denom={denom}
+     */
+    rateLimit(request: QueryRateLimitRequest): Promise<QueryRateLimitResponse>;
+    /** Queries all the rate limits for a given chain */
+    rateLimitsByChainID(request: QueryRateLimitsByChainIDRequest): Promise<QueryRateLimitsByChainIDResponse>;
+    /** Queries all the rate limits for a given channel ID */
+    rateLimitsByChannelOrClientID(request: QueryRateLimitsByChannelOrClientIDRequest): Promise<QueryRateLimitsByChannelOrClientIDResponse>;
+    /** Queries all blacklisted denoms */
+    allBlacklistedDenoms(request?: QueryAllBlacklistedDenomsRequest): Promise<QueryAllBlacklistedDenomsResponse>;
+    /** Queries all whitelisted address pairs */
+    allWhitelistedAddresses(request?: QueryAllWhitelistedAddressesRequest): Promise<QueryAllWhitelistedAddressesResponse>;
+}
+export declare class QueryClientImpl implements Query {
+    private readonly rpc;
+    constructor(rpc: TxRpc);
+    allRateLimits: (request?: QueryAllRateLimitsRequest) => Promise<QueryAllRateLimitsResponse>;
+    rateLimit: (request: QueryRateLimitRequest) => Promise<QueryRateLimitResponse>;
+    rateLimitsByChainID: (request: QueryRateLimitsByChainIDRequest) => Promise<QueryRateLimitsByChainIDResponse>;
+    rateLimitsByChannelOrClientID: (request: QueryRateLimitsByChannelOrClientIDRequest) => Promise<QueryRateLimitsByChannelOrClientIDResponse>;
+    allBlacklistedDenoms: (request?: QueryAllBlacklistedDenomsRequest) => Promise<QueryAllBlacklistedDenomsResponse>;
+    allWhitelistedAddresses: (request?: QueryAllWhitelistedAddressesRequest) => Promise<QueryAllWhitelistedAddressesResponse>;
+}
+export declare const createRpcQueryExtension: (base: QueryClient) => {
+    allRateLimits(request?: QueryAllRateLimitsRequest): Promise<QueryAllRateLimitsResponse>;
+    rateLimit(request: QueryRateLimitRequest): Promise<QueryRateLimitResponse>;
+    rateLimitsByChainID(request: QueryRateLimitsByChainIDRequest): Promise<QueryRateLimitsByChainIDResponse>;
+    rateLimitsByChannelOrClientID(request: QueryRateLimitsByChannelOrClientIDRequest): Promise<QueryRateLimitsByChannelOrClientIDResponse>;
+    allBlacklistedDenoms(request?: QueryAllBlacklistedDenomsRequest): Promise<QueryAllBlacklistedDenomsResponse>;
+    allWhitelistedAddresses(request?: QueryAllWhitelistedAddressesRequest): Promise<QueryAllWhitelistedAddressesResponse>;
+};

package/ibc/applications/rate_limiting/v1/query.rpc.Query.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
+const binary_1 = require("../../../../binary");
+const stargate_1 = require("@cosmjs/stargate");
+const query_1 = require("./query");
+class QueryClientImpl {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    /* Queries all rate limits */
+    allRateLimits = async (request = {}) => {
+        const data = query_1.QueryAllRateLimitsRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "AllRateLimits", data);
+        return promise.then(data => query_1.QueryAllRateLimitsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Queries a specific rate limit by channel ID and denom
+     Ex:
+      - /ratelimit/{channel_or_client_id}/by_denom?denom={denom} */
+    rateLimit = async (request) => {
+        const data = query_1.QueryRateLimitRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "RateLimit", data);
+        return promise.then(data => query_1.QueryRateLimitResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Queries all the rate limits for a given chain */
+    rateLimitsByChainID = async (request) => {
+        const data = query_1.QueryRateLimitsByChainIDRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "RateLimitsByChainID", data);
+        return promise.then(data => query_1.QueryRateLimitsByChainIDResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Queries all the rate limits for a given channel ID */
+    rateLimitsByChannelOrClientID = async (request) => {
+        const data = query_1.QueryRateLimitsByChannelOrClientIDRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "RateLimitsByChannelOrClientID", data);
+        return promise.then(data => query_1.QueryRateLimitsByChannelOrClientIDResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Queries all blacklisted denoms */
+    allBlacklistedDenoms = async (request = {}) => {
+        const data = query_1.QueryAllBlacklistedDenomsRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "AllBlacklistedDenoms", data);
+        return promise.then(data => query_1.QueryAllBlacklistedDenomsResponse.decode(new binary_1.BinaryReader(data)));
+    };
+    /* Queries all whitelisted address pairs */
+    allWhitelistedAddresses = async (request = {}) => {
+        const data = query_1.QueryAllWhitelistedAddressesRequest.encode(request).finish();
+        const promise = this.rpc.request("ibc.applications.rate_limiting.v1.Query", "AllWhitelistedAddresses", data);
+        return promise.then(data => query_1.QueryAllWhitelistedAddressesResponse.decode(new binary_1.BinaryReader(data)));
+    };
+}
+exports.QueryClientImpl = QueryClientImpl;
+const createRpcQueryExtension = (base) => {
+    const rpc = (0, stargate_1.createProtobufRpcClient)(base);
+    const queryService = new QueryClientImpl(rpc);
+    return {
+        allRateLimits(request) {
+            return queryService.allRateLimits(request);
+        },
+        rateLimit(request) {
+            return queryService.rateLimit(request);
+        },
+        rateLimitsByChainID(request) {
+            return queryService.rateLimitsByChainID(request);
+        },
+        rateLimitsByChannelOrClientID(request) {
+            return queryService.rateLimitsByChannelOrClientID(request);
+        },
+        allBlacklistedDenoms(request) {
+            return queryService.allBlacklistedDenoms(request);
+        },
+        allWhitelistedAddresses(request) {
+            return queryService.allWhitelistedAddresses(request);
+        }
+    };
+};
+exports.createRpcQueryExtension = createRpcQueryExtension;

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

@@ -0,0 +1,374 @@
+import { Duration, DurationAmino } from "../../../../google/protobuf/duration";
+import { BinaryReader, BinaryWriter } from "../../../../binary";
+import { DeepPartial } from "../../../../helpers";
+/**
+ * PacketDirection defines whether the transfer packet is being sent from
+ * this chain or is being received on this chain
+ */
+export declare enum PacketDirection {
+    PACKET_SEND = 0,
+    PACKET_RECV = 1,
+    UNRECOGNIZED = -1
+}
+export declare const PacketDirectionAmino: typeof PacketDirection;
+export declare function packetDirectionFromJSON(object: any): PacketDirection;
+export declare function packetDirectionToJSON(object: PacketDirection): string;
+/**
+ * Path holds the denom and channelID that define the rate limited route
+ * @name Path
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Path
+ */
+export interface Path {
+    denom: string;
+    channelOrClientId: string;
+}
+export interface PathProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Path";
+    value: Uint8Array;
+}
+/**
+ * Path holds the denom and channelID that define the rate limited route
+ * @name PathAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Path
+ */
+export interface PathAmino {
+    denom?: string;
+    channel_or_client_id?: string;
+}
+export interface PathAminoMsg {
+    type: "cosmos-sdk/Path";
+    value: PathAmino;
+}
+/**
+ * Quota defines the rate limit thresholds for transfer packets
+ * @name Quota
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Quota
+ */
+export interface Quota {
+    /**
+     * MaxPercentSend defines the threshold for outflows
+     * The threshold is defined as a percentage (e.g. 10 indicates 10%)
+     */
+    maxPercentSend: string;
+    /**
+     * MaxPercentSend defines the threshold for inflows
+     * The threshold is defined as a percentage (e.g. 10 indicates 10%)
+     */
+    maxPercentRecv: string;
+    /**
+     * DurationHours specifies the number of hours before the rate limit
+     * is reset (e.g. 24 indicates that the rate limit is reset each day)
+     */
+    durationHours: bigint;
+}
+export interface QuotaProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Quota";
+    value: Uint8Array;
+}
+/**
+ * Quota defines the rate limit thresholds for transfer packets
+ * @name QuotaAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Quota
+ */
+export interface QuotaAmino {
+    /**
+     * MaxPercentSend defines the threshold for outflows
+     * The threshold is defined as a percentage (e.g. 10 indicates 10%)
+     */
+    max_percent_send?: string;
+    /**
+     * MaxPercentSend defines the threshold for inflows
+     * The threshold is defined as a percentage (e.g. 10 indicates 10%)
+     */
+    max_percent_recv?: string;
+    /**
+     * DurationHours specifies the number of hours before the rate limit
+     * is reset (e.g. 24 indicates that the rate limit is reset each day)
+     */
+    duration_hours?: string;
+}
+export interface QuotaAminoMsg {
+    type: "cosmos-sdk/Quota";
+    value: QuotaAmino;
+}
+/**
+ * Flow tracks all the inflows and outflows of a channel.
+ * @name Flow
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Flow
+ */
+export interface Flow {
+    /**
+     * Inflow defines the total amount of inbound transfers for the given
+     * rate limit in the current window
+     */
+    inflow: string;
+    /**
+     * Outflow defines the total amount of outbound transfers for the given
+     * rate limit in the current window
+     */
+    outflow: string;
+    /**
+     * ChannelValue stores the total supply of the denom at the start of
+     * the rate limit. This is used as the denominator when checking
+     * the rate limit threshold
+     * The ChannelValue is fixed for the duration of the rate limit window
+     */
+    channelValue: string;
+}
+export interface FlowProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.Flow";
+    value: Uint8Array;
+}
+/**
+ * Flow tracks all the inflows and outflows of a channel.
+ * @name FlowAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Flow
+ */
+export interface FlowAmino {
+    /**
+     * Inflow defines the total amount of inbound transfers for the given
+     * rate limit in the current window
+     */
+    inflow?: string;
+    /**
+     * Outflow defines the total amount of outbound transfers for the given
+     * rate limit in the current window
+     */
+    outflow?: string;
+    /**
+     * ChannelValue stores the total supply of the denom at the start of
+     * the rate limit. This is used as the denominator when checking
+     * the rate limit threshold
+     * The ChannelValue is fixed for the duration of the rate limit window
+     */
+    channel_value?: string;
+}
+export interface FlowAminoMsg {
+    type: "cosmos-sdk/Flow";
+    value: FlowAmino;
+}
+/**
+ * RateLimit stores all the context about a given rate limit, including
+ * the relevant denom and channel, rate limit thresholds, and current
+ * progress towards the limits
+ * @name RateLimit
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.RateLimit
+ */
+export interface RateLimit {
+    path?: Path;
+    quota?: Quota;
+    flow?: Flow;
+}
+export interface RateLimitProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.RateLimit";
+    value: Uint8Array;
+}
+/**
+ * RateLimit stores all the context about a given rate limit, including
+ * the relevant denom and channel, rate limit thresholds, and current
+ * progress towards the limits
+ * @name RateLimitAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.RateLimit
+ */
+export interface RateLimitAmino {
+    path?: PathAmino;
+    quota?: QuotaAmino;
+    flow?: FlowAmino;
+}
+export interface RateLimitAminoMsg {
+    type: "cosmos-sdk/RateLimit";
+    value: RateLimitAmino;
+}
+/**
+ * WhitelistedAddressPair represents a sender-receiver combo that is
+ * not subject to rate limit restrictions
+ * @name WhitelistedAddressPair
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.WhitelistedAddressPair
+ */
+export interface WhitelistedAddressPair {
+    sender: string;
+    receiver: string;
+}
+export interface WhitelistedAddressPairProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.WhitelistedAddressPair";
+    value: Uint8Array;
+}
+/**
+ * WhitelistedAddressPair represents a sender-receiver combo that is
+ * not subject to rate limit restrictions
+ * @name WhitelistedAddressPairAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.WhitelistedAddressPair
+ */
+export interface WhitelistedAddressPairAmino {
+    sender?: string;
+    receiver?: string;
+}
+export interface WhitelistedAddressPairAminoMsg {
+    type: "cosmos-sdk/WhitelistedAddressPair";
+    value: WhitelistedAddressPairAmino;
+}
+/**
+ * HourEpoch is the epoch type.
+ * @name HourEpoch
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.HourEpoch
+ */
+export interface HourEpoch {
+    epochNumber: bigint;
+    duration: Duration;
+    epochStartTime: Date;
+    epochStartHeight: bigint;
+}
+export interface HourEpochProtoMsg {
+    typeUrl: "/ibc.applications.rate_limiting.v1.HourEpoch";
+    value: Uint8Array;
+}
+/**
+ * HourEpoch is the epoch type.
+ * @name HourEpochAmino
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.HourEpoch
+ */
+export interface HourEpochAmino {
+    epoch_number?: string;
+    duration?: DurationAmino;
+    epoch_start_time?: string;
+    epoch_start_height?: string;
+}
+export interface HourEpochAminoMsg {
+    type: "cosmos-sdk/HourEpoch";
+    value: HourEpochAmino;
+}
+/**
+ * Path holds the denom and channelID that define the rate limited route
+ * @name Path
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Path
+ */
+export declare const Path: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Path, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Path;
+    fromPartial(object: DeepPartial<Path>): Path;
+    fromAmino(object: PathAmino): Path;
+    toAmino(message: Path): PathAmino;
+    fromAminoMsg(object: PathAminoMsg): Path;
+    toAminoMsg(message: Path): PathAminoMsg;
+    fromProtoMsg(message: PathProtoMsg): Path;
+    toProto(message: Path): Uint8Array;
+    toProtoMsg(message: Path): PathProtoMsg;
+};
+/**
+ * Quota defines the rate limit thresholds for transfer packets
+ * @name Quota
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Quota
+ */
+export declare const Quota: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Quota, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Quota;
+    fromPartial(object: DeepPartial<Quota>): Quota;
+    fromAmino(object: QuotaAmino): Quota;
+    toAmino(message: Quota): QuotaAmino;
+    fromAminoMsg(object: QuotaAminoMsg): Quota;
+    toAminoMsg(message: Quota): QuotaAminoMsg;
+    fromProtoMsg(message: QuotaProtoMsg): Quota;
+    toProto(message: Quota): Uint8Array;
+    toProtoMsg(message: Quota): QuotaProtoMsg;
+};
+/**
+ * Flow tracks all the inflows and outflows of a channel.
+ * @name Flow
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.Flow
+ */
+export declare const Flow: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: Flow, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Flow;
+    fromPartial(object: DeepPartial<Flow>): Flow;
+    fromAmino(object: FlowAmino): Flow;
+    toAmino(message: Flow): FlowAmino;
+    fromAminoMsg(object: FlowAminoMsg): Flow;
+    toAminoMsg(message: Flow): FlowAminoMsg;
+    fromProtoMsg(message: FlowProtoMsg): Flow;
+    toProto(message: Flow): Uint8Array;
+    toProtoMsg(message: Flow): FlowProtoMsg;
+};
+/**
+ * RateLimit stores all the context about a given rate limit, including
+ * the relevant denom and channel, rate limit thresholds, and current
+ * progress towards the limits
+ * @name RateLimit
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.RateLimit
+ */
+export declare const RateLimit: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: RateLimit, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): RateLimit;
+    fromPartial(object: DeepPartial<RateLimit>): RateLimit;
+    fromAmino(object: RateLimitAmino): RateLimit;
+    toAmino(message: RateLimit): RateLimitAmino;
+    fromAminoMsg(object: RateLimitAminoMsg): RateLimit;
+    toAminoMsg(message: RateLimit): RateLimitAminoMsg;
+    fromProtoMsg(message: RateLimitProtoMsg): RateLimit;
+    toProto(message: RateLimit): Uint8Array;
+    toProtoMsg(message: RateLimit): RateLimitProtoMsg;
+};
+/**
+ * WhitelistedAddressPair represents a sender-receiver combo that is
+ * not subject to rate limit restrictions
+ * @name WhitelistedAddressPair
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.WhitelistedAddressPair
+ */
+export declare const WhitelistedAddressPair: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: WhitelistedAddressPair, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): WhitelistedAddressPair;
+    fromPartial(object: DeepPartial<WhitelistedAddressPair>): WhitelistedAddressPair;
+    fromAmino(object: WhitelistedAddressPairAmino): WhitelistedAddressPair;
+    toAmino(message: WhitelistedAddressPair): WhitelistedAddressPairAmino;
+    fromAminoMsg(object: WhitelistedAddressPairAminoMsg): WhitelistedAddressPair;
+    toAminoMsg(message: WhitelistedAddressPair): WhitelistedAddressPairAminoMsg;
+    fromProtoMsg(message: WhitelistedAddressPairProtoMsg): WhitelistedAddressPair;
+    toProto(message: WhitelistedAddressPair): Uint8Array;
+    toProtoMsg(message: WhitelistedAddressPair): WhitelistedAddressPairProtoMsg;
+};
+/**
+ * HourEpoch is the epoch type.
+ * @name HourEpoch
+ * @package ibc.applications.rate_limiting.v1
+ * @see proto type: ibc.applications.rate_limiting.v1.HourEpoch
+ */
+export declare const HourEpoch: {
+    typeUrl: string;
+    aminoType: string;
+    encode(message: HourEpoch, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): HourEpoch;
+    fromPartial(object: DeepPartial<HourEpoch>): HourEpoch;
+    fromAmino(object: HourEpochAmino): HourEpoch;
+    toAmino(message: HourEpoch): HourEpochAmino;
+    fromAminoMsg(object: HourEpochAminoMsg): HourEpoch;
+    toAminoMsg(message: HourEpoch): HourEpochAminoMsg;
+    fromProtoMsg(message: HourEpochProtoMsg): HourEpoch;
+    toProto(message: HourEpoch): Uint8Array;
+    toProtoMsg(message: HourEpoch): HourEpochProtoMsg;
+};