@initia/initia.js 1.0.6 → 1.0.8

package/dist/client/rest/APIRequester.d.ts

@@ -1,4 +1,4 @@
-import { AxiosHeaders, CreateAxiosDefaults } from 'axios';
+import { CreateAxiosDefaults } from 'axios';
 import { OrderBy as OrderBy_pb } from '@initia/initia.proto/cosmos/tx/v1beta1/service';
 export type APIParams = Record<string, string | number | null | undefined>;
 export interface Pagination {
@@ -21,7 +21,7 @@ export declare class APIRequester {
     constructor(baseURL: string, config?: CreateAxiosDefaults<any> | undefined);
     private validateEndpoint;
     private computeEndpoint;
-    getRaw<T>(endpoint: string, params?: URLSearchParams | APIParams): Promise<T>;
-    get<T>(endpoint: string, params?: URLSearchParams | APIParams, headers?: AxiosHeaders): Promise<T>;
-    post<T>(endpoint: string, data?: any): Promise<T>;
+    getRaw<T>(endpoint: string, params?: URLSearchParams | APIParams, headers?: Record<string, string>): Promise<T>;
+    get<T>(endpoint: string, params?: URLSearchParams | APIParams, headers?: Record<string, string>): Promise<T>;
+    post<T>(endpoint: string, data?: any, headers?: Record<string, string>): Promise<T>;
 }

package/dist/client/rest/api/AuctionAPI.d.ts

@@ -2,5 +2,5 @@ import { AuctionParams } from '../../../core/auction';
 import { APIParams } from '../APIRequester';
 import { BaseAPI } from './BaseAPI';
 export declare class AuctionAPI extends BaseAPI {
-    parameters(params?: APIParams): Promise<AuctionParams>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<AuctionParams>;
 }

package/dist/client/rest/api/AuthAPI.d.ts

@@ -2,7 +2,7 @@ import { AccAddress, Account, ModuleAccount, AuthParams } from '../../../core';
 import { BaseAPI } from './BaseAPI';
 import { APIParams } from '../APIRequester';
 export declare class AuthAPI extends BaseAPI {
-    accountInfo(address: AccAddress, params?: APIParams): Promise<Account>;
-    moduleAccount(name: string, params?: APIParams): Promise<ModuleAccount>;
-    parameters(params?: APIParams): Promise<AuthParams>;
+    accountInfo(address: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Account>;
+    moduleAccount(name: string, params?: APIParams, headers?: Record<string, string>): Promise<ModuleAccount>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<AuthParams>;
 }

package/dist/client/rest/api/AuthzAPI.d.ts

@@ -2,7 +2,7 @@ import { AccAddress, AuthorizationGrant } from '../../../core';
 import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination } from '../APIRequester';
 export declare class AuthzAPI extends BaseAPI {
-    grants(granter: AccAddress, grantee: AccAddress, msg_type_url?: string, params?: APIParams): Promise<[AuthorizationGrant[], Pagination]>;
-    granter(granter: AccAddress, params?: APIParams): Promise<[AuthorizationGrant[], Pagination]>;
-    grantee(grantee: AccAddress, params?: APIParams): Promise<[AuthorizationGrant[], Pagination]>;
+    grants(granter: AccAddress, grantee: AccAddress, msg_type_url?: string, params?: APIParams, headers?: Record<string, string>): Promise<[AuthorizationGrant[], Pagination]>;
+    granter(granter: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<[AuthorizationGrant[], Pagination]>;
+    grantee(grantee: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<[AuthorizationGrant[], Pagination]>;
 }

package/dist/client/rest/api/BankAPI.d.ts

@@ -2,9 +2,9 @@ import { BaseAPI } from './BaseAPI';
 import { Coins, Coin, AccAddress, BankParams, Denom } from '../../../core';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 export declare class BankAPI extends BaseAPI {
-    balance(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Coins, Pagination]>;
-    balanceByDenom(address: AccAddress, denom: Denom, params?: APIParams): Promise<Coin>;
-    total(params?: Partial<PaginationOptions & APIParams>): Promise<[Coins, Pagination]>;
-    spendableBalances(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Coins, Pagination]>;
-    parameters(params?: APIParams): Promise<BankParams>;
+    balance(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Coins, Pagination]>;
+    balanceByDenom(address: AccAddress, denom: Denom, params?: APIParams, headers?: Record<string, string>): Promise<Coin>;
+    total(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Coins, Pagination]>;
+    spendableBalances(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Coins, Pagination]>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<BankParams>;
 }

package/dist/client/rest/api/DistributionAPI.d.ts

@@ -25,11 +25,11 @@ export declare namespace Rewards {
     }
 }
 export declare class DistributionAPI extends BaseAPI {
-    rewards(delegator: AccAddress, params?: APIParams): Promise<Rewards>;
-    rewardsByValidator(delegator: AccAddress, validator: AccAddress, params?: APIParams): Promise<Pool[]>;
-    validatorRewards(validator: AccAddress, params?: APIParams): Promise<Pool[]>;
-    validatorCommission(validator: ValAddress, params?: APIParams): Promise<Pool[]>;
-    withdrawAddress(delegator: AccAddress, params?: APIParams): Promise<AccAddress>;
-    communityPool(params?: APIParams): Promise<Coins>;
-    parameters(params?: APIParams): Promise<DistributionParams>;
+    rewards(delegator: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Rewards>;
+    rewardsByValidator(delegator: AccAddress, validator: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Pool[]>;
+    validatorRewards(validator: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Pool[]>;
+    validatorCommission(validator: ValAddress, params?: APIParams, headers?: Record<string, string>): Promise<Pool[]>;
+    withdrawAddress(delegator: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<AccAddress>;
+    communityPool(params?: APIParams, headers?: Record<string, string>): Promise<Coins>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<DistributionParams>;
 }

package/dist/client/rest/api/EvidenceAPI.d.ts

@@ -2,6 +2,6 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 import { Evidence } from '../../../core';
 export declare class EvidenceAPI extends BaseAPI {
-    evidences(params?: Partial<PaginationOptions & APIParams>): Promise<[Evidence[], Pagination]>;
-    evidence(hash: string, params?: APIParams): Promise<Evidence>;
+    evidences(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Evidence[], Pagination]>;
+    evidence(hash: string, params?: APIParams, headers?: Record<string, string>): Promise<Evidence>;
 }

package/dist/client/rest/api/EvmAPI.d.ts

@@ -12,12 +12,12 @@ export interface CallResponse {
     trace_output: string;
 }
 export declare class EvmAPI extends BaseAPI {
-    code(contract_addr: AccAddress, params?: APIParams): Promise<string>;
-    state(contract_addr: AccAddress, key: string, params?: APIParams): Promise<string>;
-    erc20Factory(params?: APIParams): Promise<string>;
-    erc20Wrapper(params?: APIParams): Promise<string>;
-    contractAddrByDenom(denom: string, params?: APIParams): Promise<AccAddress>;
-    denom(contract_addr: AccAddress, params?: APIParams): Promise<string>;
-    call(sender: AccAddress, contract_addr: AccAddress, input: string, with_trace: boolean): Promise<CallResponse>;
-    parameters(params?: APIParams): Promise<EvmParams>;
+    code(contract_addr: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    state(contract_addr: AccAddress, key: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    erc20Factory(params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    erc20Wrapper(params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    contractAddrByDenom(denom: string, params?: APIParams, headers?: Record<string, string>): Promise<AccAddress>;
+    denom(contract_addr: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    call(sender: AccAddress, contract_addr: AccAddress, input: string, with_trace: boolean, headers?: Record<string, string>): Promise<CallResponse>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<EvmParams>;
 }

package/dist/client/rest/api/FeeGrantAPI.d.ts

@@ -1,8 +1,8 @@
 import { AccAddress, Allowance } from '../../../core';
 import { BaseAPI } from './BaseAPI';
-import { Pagination, PaginationOptions } from '../APIRequester';
+import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 export declare class FeeGrantAPI extends BaseAPI {
-    allowances(grantee: AccAddress, params?: Partial<PaginationOptions>): Promise<{
+    allowances(grantee: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<{
         allowances: {
             granter: AccAddress;
             grantee: AccAddress;
@@ -10,8 +10,8 @@ export declare class FeeGrantAPI extends BaseAPI {
         }[];
         pagination: Pagination;
     }>;
-    allowance(granter: AccAddress, grantee: AccAddress): Promise<Allowance>;
-    allowancesByGranter(granter: AccAddress, params?: Partial<PaginationOptions>): Promise<{
+    allowance(granter: AccAddress, grantee: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Allowance>;
+    allowancesByGranter(granter: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<{
         allowances: {
             granter: AccAddress;
             grantee: AccAddress;

package/dist/client/rest/api/ForwardingAPI.d.ts

@@ -14,7 +14,7 @@ export declare namespace ForwardingStats {
     }
 }
 export declare class ForwardingAPI extends BaseAPI {
-    denoms(params?: APIParams): Promise<string[]>;
-    address(channel: string, recipient: string, fallback: string, params?: APIParams): Promise<AccAddress>;
-    stats(channel: string, params?: APIParams): Promise<ForwardingStats>;
+    denoms(params?: APIParams, headers?: Record<string, string>): Promise<string[]>;
+    address(channel: string, recipient: string, fallback: string, params?: APIParams, headers?: Record<string, string>): Promise<AccAddress>;
+    stats(channel: string, params?: APIParams, headers?: Record<string, string>): Promise<ForwardingStats>;
 }

package/dist/client/rest/api/GovAPI.d.ts

@@ -2,11 +2,11 @@ import { BaseAPI } from './BaseAPI';
 import { Proposal, Deposit, Vote, GovParams, TallyResult } from '../../../core';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 export declare class GovAPI extends BaseAPI {
-    proposals(params?: Partial<PaginationOptions & APIParams>): Promise<[Proposal[], Pagination]>;
-    proposal(proposal_id: number, params?: APIParams): Promise<Proposal>;
-    deposits(proposal_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[Deposit[], Pagination]>;
-    votes(proposal_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[Vote[], Pagination]>;
-    tally(proposal_id: number, params?: APIParams): Promise<TallyResult>;
-    parameters(params?: APIParams): Promise<GovParams>;
-    emergencyProposals(params?: Partial<PaginationOptions & APIParams>): Promise<[Proposal[], Pagination]>;
+    proposals(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Proposal[], Pagination]>;
+    proposal(proposal_id: number, params?: APIParams, headers?: Record<string, string>): Promise<Proposal>;
+    deposits(proposal_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Deposit[], Pagination]>;
+    votes(proposal_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Vote[], Pagination]>;
+    tally(proposal_id: number, params?: APIParams, headers?: Record<string, string>): Promise<TallyResult>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<GovParams>;
+    emergencyProposals(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Proposal[], Pagination]>;
 }

package/dist/client/rest/api/GroupAPI.d.ts

@@ -2,18 +2,18 @@ import { BaseAPI } from './BaseAPI';
 import { AccAddress, GroupInfo, GroupMember, GroupPolicyInfo, GroupProposal, GroupVote } from '../../../core';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 export declare class GroupAPI extends BaseAPI {
-    groupInfo(group_id: number): Promise<GroupInfo>;
-    groupPolicyInfo(address: AccAddress): Promise<GroupPolicyInfo>;
-    groupMembers(group_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupMember[], Pagination]>;
-    groupsByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupInfo[], Pagination]>;
-    groupPoliciesByGroup(group_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupPolicyInfo[], Pagination]>;
-    groupPoliciesByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupPolicyInfo[], Pagination]>;
-    proposal(proposal_id: number): Promise<GroupProposal>;
-    proposalsByGroupPolicy(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupProposal[], Pagination]>;
-    voteByProposalVoter(proposal_id: number, voter: AccAddress): Promise<GroupVote>;
-    votesByProposal(proposal_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupVote[], Pagination]>;
-    votesByVoter(voter: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupVote[], Pagination]>;
-    groupsByMember(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupInfo[], Pagination]>;
-    tally(proposal_id: number): Promise<GroupProposal.FinalTallyResult>;
-    groups(params?: Partial<PaginationOptions & APIParams>): Promise<[GroupInfo[], Pagination]>;
+    groupInfo(group_id: number, params?: APIParams, headers?: Record<string, string>): Promise<GroupInfo>;
+    groupPolicyInfo(address: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<GroupPolicyInfo>;
+    groupMembers(group_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupMember[], Pagination]>;
+    groupsByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupInfo[], Pagination]>;
+    groupPoliciesByGroup(group_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupPolicyInfo[], Pagination]>;
+    groupPoliciesByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupPolicyInfo[], Pagination]>;
+    proposal(proposal_id: number, params?: APIParams, headers?: Record<string, string>): Promise<GroupProposal>;
+    proposalsByGroupPolicy(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupProposal[], Pagination]>;
+    voteByProposalVoter(proposal_id: number, voter: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<GroupVote>;
+    votesByProposal(proposal_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupVote[], Pagination]>;
+    votesByVoter(voter: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupVote[], Pagination]>;
+    groupsByMember(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupInfo[], Pagination]>;
+    tally(proposal_id: number, params?: APIParams, headers?: Record<string, string>): Promise<GroupProposal.FinalTallyResult>;
+    groups(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[GroupInfo[], Pagination]>;
 }

package/dist/client/rest/api/IbcAPI.d.ts

@@ -1,6 +1,6 @@
 import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
-import { IdentifiedClientState, ClientConsensusStates, Channel, IdentifiedConnection, Height, IbcClientParams, IdentifiedChannel } from '../../../core';
+import { IdentifiedClientState, Channel, IdentifiedConnection, Height, IbcClientParams, IdentifiedChannel, ConsensusStateWithHeight } from '../../../core';
 export interface ClientState {
     client_state: any;
     proof: string | null;
@@ -26,22 +26,22 @@ export declare namespace Port {
     }
 }
 export declare class IbcAPI extends BaseAPI {
-    channels(params?: APIParams): Promise<[IdentifiedChannel[], Height, Pagination]>;
-    port(channel_id: string, port_id: string, params?: APIParams): Promise<Port>;
-    connections(params?: APIParams): Promise<[IdentifiedConnection[], Pagination]>;
-    connection(connection_id: string, params?: APIParams): Promise<IdentifiedConnection>;
-    connectionChannels(connection_id: string, params?: APIParams): Promise<[IdentifiedChannel[], Height, Pagination]>;
-    parameters(params?: APIParams): Promise<IbcClientParams>;
-    clientStates(params?: Partial<PaginationOptions & APIParams>): Promise<[IdentifiedClientState[], Pagination]>;
-    clientState(client_id: string, params?: APIParams): Promise<ClientState>;
-    clientStatus(client_id: string, params?: APIParams): Promise<string>;
-    consensusStates(client_id: string, params?: Partial<PaginationOptions & APIParams>): Promise<[ClientConsensusStates, Pagination]>;
-    consensusStateHeights(client_id: string, params?: Partial<PaginationOptions & APIParams>): Promise<[Height[], Pagination]>;
-    unreceivedPackets(port_id: string, channel_id: string, sequences: number[], params?: APIParams): Promise<{
+    channels(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[IdentifiedChannel[], Height, Pagination]>;
+    port(channel_id: string, port_id: string, params?: APIParams, headers?: Record<string, string>): Promise<Port>;
+    connections(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[IdentifiedConnection[], Pagination]>;
+    connection(connection_id: string, params?: APIParams, headers?: Record<string, string>): Promise<IdentifiedConnection>;
+    connectionChannels(connection_id: string, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[IdentifiedChannel[], Height, Pagination]>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<IbcClientParams>;
+    clientStates(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[IdentifiedClientState[], Pagination]>;
+    clientState(client_id: string, params?: APIParams, headers?: Record<string, string>): Promise<ClientState>;
+    clientStatus(client_id: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    consensusStates(client_id: string, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[ConsensusStateWithHeight[], Pagination]>;
+    consensusStateHeights(client_id: string, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Height[], Pagination]>;
+    unreceivedPackets(port_id: string, channel_id: string, sequences: number[], params?: APIParams, headers?: Record<string, string>): Promise<{
         sequences: string[];
         height: Height;
     }>;
-    unreceivedAcks(port_id: string, channel_id: string, sequences: number[], params?: APIParams): Promise<{
+    unreceivedAcks(port_id: string, channel_id: string, sequences: number[], params?: APIParams, headers?: Record<string, string>): Promise<{
         sequences: string[];
         height: Height;
     }>;

package/dist/client/rest/api/IbcHooksAPI.d.ts

@@ -2,7 +2,7 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 import { AccAddress, ACL, IbcHooksParams } from '../../../core';
 export declare class IbcHooksAPI extends BaseAPI {
-    acls(params?: Partial<PaginationOptions & APIParams>): Promise<[ACL[], Pagination]>;
-    acl(address: AccAddress, params?: APIParams): Promise<ACL>;
-    parameters(params?: APIParams): Promise<IbcHooksParams>;
+    acls(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[ACL[], Pagination]>;
+    acl(address: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<ACL>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<IbcHooksParams>;
 }

package/dist/client/rest/api/IbcNftAPI.d.ts

@@ -2,9 +2,9 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 import { NftClassTrace, IbcNftParams } from '../../../core';
 export declare class IbcNftAPI extends BaseAPI {
-    classTrace(hash: string): Promise<NftClassTrace>;
-    classTraces(params?: Partial<PaginationOptions & APIParams>): Promise<[NftClassTrace[], Pagination]>;
-    classHash(trace: string): Promise<string>;
-    escrowAddress(channel_id: string, port_id: string, params?: APIParams): Promise<string>;
-    parameters(params?: APIParams): Promise<IbcNftParams>;
+    classTrace(hash: string, params?: APIParams, headers?: Record<string, string>): Promise<NftClassTrace>;
+    classTraces(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[NftClassTrace[], Pagination]>;
+    classHash(trace: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    escrowAddress(channel_id: string, port_id: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<IbcNftParams>;
 }

package/dist/client/rest/api/IbcPermAPI.d.ts

@@ -7,6 +7,6 @@ export interface ChannelState {
     relayers: string[];
 }
 export declare class IbcPermAPI extends BaseAPI {
-    channelStates(params?: Partial<PaginationOptions & APIParams>): Promise<[ChannelState[], Pagination]>;
-    channelState(channel_id: string, port_id: string): Promise<ChannelState>;
+    channelStates(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[ChannelState[], Pagination]>;
+    channelState(channel_id: string, port_id: string, params?: APIParams, headers?: Record<string, string>): Promise<ChannelState>;
 }

package/dist/client/rest/api/IbcTransferAPI.d.ts

@@ -2,9 +2,9 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 import { DenomTrace, IbcTransferParams } from '../../../core';
 export declare class IbcTransferAPI extends BaseAPI {
-    denomTrace(hash: string): Promise<DenomTrace>;
-    denomTraces(params?: Partial<PaginationOptions & APIParams>): Promise<[DenomTrace[], Pagination]>;
-    denomHash(trace: string): Promise<string>;
-    parameters(params?: APIParams): Promise<IbcTransferParams>;
-    escrowAddress(channel_id: string, port_id: string, params?: APIParams): Promise<string>;
+    denomTrace(hash: string, params?: APIParams, headers?: Record<string, string>): Promise<DenomTrace>;
+    denomTraces(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[DenomTrace[], Pagination]>;
+    denomHash(trace: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<IbcTransferParams>;
+    escrowAddress(channel_id: string, port_id: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
 }

package/dist/client/rest/api/InterTxAPI.d.ts

@@ -1,5 +1,6 @@
 import { AccAddress } from '../../../core';
 import { BaseAPI } from './BaseAPI';
+import { APIParams } from '../APIRequester';
 export declare class InterTxAPI extends BaseAPI {
-    interchainAccount(owner: AccAddress, connection_id: string): Promise<string>;
+    interchainAccount(owner: AccAddress, connection_id: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
 }

package/dist/client/rest/api/MarketmapAPI.d.ts

@@ -10,9 +10,9 @@ export declare namespace MarketMap {
     }
 }
 export declare class MarketmapAPI extends BaseAPI {
-    marketMap(params?: APIParams): Promise<MarketMap>;
-    markets(params?: APIParams): Promise<Market[]>;
-    market(pair: CurrencyPair, params?: APIParams): Promise<Market>;
-    lastUpdated(params?: APIParams): Promise<number>;
-    parameters(params?: APIParams): Promise<MarketmapParams>;
+    marketMap(params?: APIParams, headers?: Record<string, string>): Promise<MarketMap>;
+    markets(params?: APIParams, headers?: Record<string, string>): Promise<Market[]>;
+    market(pair: CurrencyPair, params?: APIParams, headers?: Record<string, string>): Promise<Market>;
+    lastUpdated(params?: APIParams, headers?: Record<string, string>): Promise<number>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<MarketmapParams>;
 }

package/dist/client/rest/api/MoveAPI.d.ts

@@ -37,26 +37,26 @@ export interface VMEvent {
     data: string;
 }
 export declare class MoveAPI extends BaseAPI {
-    modules(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Module[], Pagination]>;
-    module(address: AccAddress, module_name: string, params?: APIParams): Promise<Module>;
-    resources(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[{
+    modules(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Module[], Pagination]>;
+    module(address: AccAddress, module_name: string, params?: APIParams, headers?: Record<string, string>): Promise<Module>;
+    resources(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[{
         type: string;
         data: any;
     }[], Pagination]>;
-    resource<T>(address: AccAddress, struct_tag: string, params?: APIParams): Promise<{
+    resource<T>(address: AccAddress, struct_tag: string, params?: APIParams, headers?: Record<string, string>): Promise<{
         type: string;
         data: T;
     }>;
-    tableInfo(address: AccAddress, params?: APIParams): Promise<TableInfo>;
-    tableEntries(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[TableEntry[], Pagination]>;
-    tableEntry(address: AccAddress, key_bytes: string, params?: APIParams): Promise<TableEntry>;
-    viewFunction<T>(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[]): Promise<T>;
-    view(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[]): Promise<ViewResponse>;
-    viewBatch(requests: ViewRequest[]): Promise<ViewResponse[]>;
-    viewJSON(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[]): Promise<ViewResponse>;
-    viewBatchJSON(requests: ViewRequest[]): Promise<ViewResponse[]>;
-    scriptABI(code_bytes: string): Promise<ABI>;
-    denom(metadata: string, params?: APIParams): Promise<Denom>;
-    metadata(denom: Denom, params?: APIParams): Promise<string>;
-    parameters(params?: APIParams): Promise<MoveParams>;
+    tableInfo(address: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<TableInfo>;
+    tableEntries(address: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[TableEntry[], Pagination]>;
+    tableEntry(address: AccAddress, key_bytes: string, params?: APIParams, headers?: Record<string, string>): Promise<TableEntry>;
+    viewFunction<T>(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[], headers?: Record<string, string>): Promise<T>;
+    view(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[], headers?: Record<string, string>): Promise<ViewResponse>;
+    viewBatch(requests: ViewRequest[], headers?: Record<string, string>): Promise<ViewResponse[]>;
+    viewJSON(address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[], headers?: Record<string, string>): Promise<ViewResponse>;
+    viewBatchJSON(requests: ViewRequest[], headers?: Record<string, string>): Promise<ViewResponse[]>;
+    scriptABI(code_bytes: string, headers?: Record<string, string>): Promise<ABI>;
+    denom(metadata: string, params?: APIParams, headers?: Record<string, string>): Promise<Denom>;
+    metadata(denom: Denom, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<MoveParams>;
 }

package/dist/client/rest/api/MstakingAPI.d.ts

@@ -12,15 +12,15 @@ export declare namespace MstakingPool {
     }
 }
 export declare class MstakingAPI extends BaseAPI {
-    delegations(delegator?: AccAddress, validator?: ValAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Delegation[], Pagination]>;
-    delegation(delegator: AccAddress, validator: ValAddress): Promise<Delegation>;
-    unbondingDelegations(delegator?: AccAddress, validator?: ValAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[UnbondingDelegation[], Pagination]>;
-    unbondingDelegation(delegator?: AccAddress, validator?: ValAddress): Promise<UnbondingDelegation>;
-    redelegations(delegator: AccAddress, src_validator_addr?: ValAddress, dst_validator_addr?: ValAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Redelegation[], Pagination]>;
-    bondedValidators(delegator: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Validator[], Pagination]>;
-    totalDelegationBalance(delegator: AccAddress, params?: APIParams): Promise<Coins>;
-    validators(params?: Partial<PaginationOptions & APIParams>): Promise<[Validator[], Pagination]>;
-    validator(validator: ValAddress, params?: APIParams): Promise<Validator>;
-    pool(params?: APIParams): Promise<MstakingPool>;
-    parameters(params?: APIParams): Promise<MstakingParams>;
+    delegations(delegator?: AccAddress, validator?: ValAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Delegation[], Pagination]>;
+    delegation(delegator: AccAddress, validator: ValAddress, headers?: Record<string, string>): Promise<Delegation>;
+    unbondingDelegations(delegator?: AccAddress, validator?: ValAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[UnbondingDelegation[], Pagination]>;
+    unbondingDelegation(delegator?: AccAddress, validator?: ValAddress, headers?: Record<string, string>): Promise<UnbondingDelegation>;
+    redelegations(delegator: AccAddress, src_validator_addr?: ValAddress, dst_validator_addr?: ValAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Redelegation[], Pagination]>;
+    bondedValidators(delegator: AccAddress, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Validator[], Pagination]>;
+    totalDelegationBalance(delegator: AccAddress, params?: APIParams, headers?: Record<string, string>): Promise<Coins>;
+    validators(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[Validator[], Pagination]>;
+    validator(validator: ValAddress, params?: APIParams, headers?: Record<string, string>): Promise<Validator>;
+    pool(params?: APIParams, headers?: Record<string, string>): Promise<MstakingPool>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<MstakingParams>;
 }

package/dist/client/rest/api/OpchildAPI.d.ts

@@ -2,11 +2,11 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 import { OpValidator, ValAddress, OpchildParams, BridgeInfo } from '../../../core';
 export declare class OpchildAPI extends BaseAPI {
-    validators(params?: Partial<PaginationOptions & APIParams>): Promise<[OpValidator[], Pagination]>;
-    validator(validator_addr: ValAddress, params?: APIParams): Promise<OpValidator>;
-    bridgeInfo(params?: APIParams): Promise<BridgeInfo>;
-    nextL1Sequence(params?: APIParams): Promise<number>;
-    nextL2Sequence(params?: APIParams): Promise<number>;
-    baseDenom(denom: string, params?: APIParams): Promise<string>;
-    parameters(params?: APIParams): Promise<OpchildParams>;
+    validators(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[OpValidator[], Pagination]>;
+    validator(validator_addr: ValAddress, params?: APIParams, headers?: Record<string, string>): Promise<OpValidator>;
+    bridgeInfo(params?: APIParams, headers?: Record<string, string>): Promise<BridgeInfo>;
+    nextL1Sequence(params?: APIParams, headers?: Record<string, string>): Promise<number>;
+    nextL2Sequence(params?: APIParams, headers?: Record<string, string>): Promise<number>;
+    baseDenom(denom: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<OpchildParams>;
 }

package/dist/client/rest/api/OphostAPI.d.ts

@@ -18,16 +18,16 @@ export declare namespace OutputInfo {
     }
 }
 export declare class OphostAPI extends BaseAPI {
-    bridgeInfos(params?: Partial<PaginationOptions & APIParams>): Promise<[BridgeInfo[], Pagination]>;
-    bridgeInfo(bridge_id: number, params?: APIParams): Promise<BridgeInfo>;
-    tokenPairs(bridge_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[TokenPair[], Pagination]>;
-    tokenPairByL1Denom(bridge_id: number, l1_denom: string, params?: APIParams): Promise<TokenPair>;
-    tokenPairByL2Denom(bridge_id: number, l2_denom: string, params?: APIParams): Promise<TokenPair>;
-    lastFinalizedOutput(bridge_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<OutputInfo>;
-    outputInfos(bridge_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[OutputInfo[], Pagination]>;
-    outputInfo(bridge_id: number, output_index: number, params?: APIParams): Promise<OutputInfo>;
-    withdrawalClaimed(bridge_id: number, withdrawal_hash: string, params?: APIParams): Promise<boolean>;
-    nextL1Sequence(bridge_id: number, params?: APIParams): Promise<number>;
-    batchInfos(bridge_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[BatchInfoWithOutput[], Pagination]>;
-    parameters(params?: APIParams): Promise<OphostParams>;
+    bridgeInfos(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[BridgeInfo[], Pagination]>;
+    bridgeInfo(bridge_id: number, params?: APIParams, headers?: Record<string, string>): Promise<BridgeInfo>;
+    tokenPairs(bridge_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[TokenPair[], Pagination]>;
+    tokenPairByL1Denom(bridge_id: number, l1_denom: string, params?: APIParams, headers?: Record<string, string>): Promise<TokenPair>;
+    tokenPairByL2Denom(bridge_id: number, l2_denom: string, params?: APIParams, headers?: Record<string, string>): Promise<TokenPair>;
+    lastFinalizedOutput(bridge_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<OutputInfo>;
+    outputInfos(bridge_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[OutputInfo[], Pagination]>;
+    outputInfo(bridge_id: number, output_index: number, params?: APIParams, headers?: Record<string, string>): Promise<OutputInfo>;
+    withdrawalClaimed(bridge_id: number, withdrawal_hash: string, params?: APIParams, headers?: Record<string, string>): Promise<boolean>;
+    nextL1Sequence(bridge_id: number, params?: APIParams, headers?: Record<string, string>): Promise<number>;
+    batchInfos(bridge_id: number, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[BatchInfoWithOutput[], Pagination]>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<OphostParams>;
 }

package/dist/client/rest/api/OracleAPI.d.ts

@@ -2,6 +2,6 @@ import { BaseAPI } from './BaseAPI';
 import { APIParams } from '../APIRequester';
 import { CurrencyPair, QuotePrice } from '../../../core';
 export declare class OracleAPI extends BaseAPI {
-    currencyPairs(params?: APIParams): Promise<CurrencyPair[]>;
-    price(pair: CurrencyPair, params?: APIParams): Promise<QuotePrice>;
+    currencyPairs(params?: APIParams, headers?: Record<string, string>): Promise<CurrencyPair[]>;
+    price(pair: CurrencyPair, params?: APIParams, headers?: Record<string, string>): Promise<QuotePrice>;
 }

package/dist/client/rest/api/RewardAPI.d.ts

@@ -2,7 +2,7 @@ import { RewardParams } from '../../../core';
 import { APIParams } from '../APIRequester';
 import { BaseAPI } from './BaseAPI';
 export declare class RewardAPI extends BaseAPI {
-    last_dilution_timestamp(params?: APIParams): Promise<string>;
-    annualProvisions(params?: APIParams): Promise<string>;
-    parameters(params?: APIParams): Promise<RewardParams>;
+    last_dilution_timestamp(params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    annualProvisions(params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<RewardParams>;
 }

package/dist/client/rest/api/SlashingAPI.d.ts

@@ -1,8 +1,8 @@
 import { BaseAPI } from './BaseAPI';
 import { ValConsAddress, SlashingParams, ValidatorSigningInfo } from '../../../core';
-import { APIParams, Pagination } from '../APIRequester';
+import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
 export declare class SlashingAPI extends BaseAPI {
-    signingInfos(params?: APIParams): Promise<[ValidatorSigningInfo[], Pagination]>;
-    signingInfo(val_cons_address: ValConsAddress, params?: APIParams): Promise<ValidatorSigningInfo>;
-    parameters(params?: APIParams): Promise<SlashingParams>;
+    signingInfos(params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<[ValidatorSigningInfo[], Pagination]>;
+    signingInfo(val_cons_address: ValConsAddress, params?: APIParams, headers?: Record<string, string>): Promise<ValidatorSigningInfo>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<SlashingParams>;
 }

package/dist/client/rest/api/TendermintAPI.d.ts

@@ -8,9 +8,9 @@ export interface DelegateValidator {
     voting_power: string;
 }
 export declare class TendermintAPI extends BaseAPI {
-    nodeInfo(params?: APIParams): Promise<object>;
-    chainId(params?: APIParams): Promise<string>;
-    syncing(params?: APIParams): Promise<boolean>;
-    validatorSet(height?: number, params?: APIParams): Promise<[DelegateValidator[], Pagination]>;
-    blockInfo(height?: number, params?: APIParams): Promise<BlockInfo>;
+    nodeInfo(params?: APIParams, headers?: Record<string, string>): Promise<object>;
+    chainId(params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    syncing(params?: APIParams, headers?: Record<string, string>): Promise<boolean>;
+    validatorSet(height?: number, params?: APIParams, headers?: Record<string, string>): Promise<[DelegateValidator[], Pagination]>;
+    blockInfo(height?: number, params?: APIParams, headers?: Record<string, string>): Promise<BlockInfo>;
 }

package/dist/client/rest/api/TokenfactoryAPI.d.ts

@@ -5,8 +5,8 @@ export interface AuthorityMetadata {
     admin: string;
 }
 export declare class TokenfactoryAPI extends BaseAPI {
-    authorityMetadata(denom: string, params?: APIParams): Promise<AuthorityMetadata>;
-    beforeSendHookAddr(denom: string, params?: APIParams): Promise<string>;
-    denomsFromCreator(creator: string, params?: APIParams): Promise<string[]>;
-    parameters(params?: APIParams): Promise<TokenfactoryParams>;
+    authorityMetadata(denom: string, params?: APIParams, headers?: Record<string, string>): Promise<AuthorityMetadata>;
+    beforeSendHookAddr(denom: string, params?: APIParams, headers?: Record<string, string>): Promise<string>;
+    denomsFromCreator(creator: string, params?: APIParams, headers?: Record<string, string>): Promise<string[]>;
+    parameters(params?: APIParams, headers?: Record<string, string>): Promise<TokenfactoryParams>;
 }

package/dist/client/rest/api/TxAPI.d.ts

@@ -164,27 +164,27 @@ export interface TxSearchOptions extends PaginationOptions {
 export declare class TxAPI extends BaseAPI {
     rest: RESTClient;
     constructor(rest: RESTClient);
-    txInfo(tx_hash: string, params?: APIParams): Promise<TxInfo>;
+    txInfo(tx_hash: string, params?: APIParams, headers?: Record<string, string>): Promise<TxInfo>;
     create(signers: SignerOptions[], options: CreateTxOptions): Promise<Tx>;
     txInfosByHeight(height: number | undefined): Promise<TxInfo[]>;
     estimateFee(signers: SignerData[], options: CreateTxOptions): Promise<Fee>;
     estimateGas(tx: Tx, options?: {
         gasAdjustment?: number | string;
         signers?: SignerData[];
-    }): Promise<string>;
+    }, headers?: Record<string, string>): Promise<string>;
     simulate(options: CreateTxOptions & {
         sequence: number;
-    }): Promise<SimulateResponse>;
+    }, headers?: Record<string, string>): Promise<SimulateResponse>;
     static encode(tx: Tx): string;
     static decode(encoded_tx: string): Tx;
     static hash(tx: Tx): string;
     private _broadcast;
-    broadcast(tx: Tx | string, timeout?: number): Promise<WaitTxBroadcastResult>;
-    broadcastSync(tx: Tx | string): Promise<SyncTxBroadcastResult>;
-    broadcastAsync(tx: Tx | string): Promise<AsyncTxBroadcastResult>;
-    search(options: Partial<TxSearchOptions>): Promise<TxSearchResult>;
-    searchEvents(module_addr: string, module_name: string, start_height: number, end_height: number): Promise<Event[]>;
-    gasPrices(params?: APIParams): Promise<Coins>;
-    gasPrice(denom: Denom, params?: APIParams): Promise<Coin>;
+    broadcast(tx: Tx | string, timeout?: number, headers?: Record<string, string>): Promise<WaitTxBroadcastResult>;
+    broadcastSync(tx: Tx | string, headers?: Record<string, string>): Promise<SyncTxBroadcastResult>;
+    broadcastAsync(tx: Tx | string, headers?: Record<string, string>): Promise<AsyncTxBroadcastResult>;
+    search(options: Partial<TxSearchOptions>, headers?: Record<string, string>): Promise<TxSearchResult>;
+    searchEvents(module_addr: string, module_name: string, start_height: number, end_height: number, headers?: Record<string, string>): Promise<Event[]>;
+    gasPrices(params?: APIParams, headers?: Record<string, string>): Promise<Coins>;
+    gasPrice(denom: Denom, params?: APIParams, headers?: Record<string, string>): Promise<Coin>;
 }
 export {};

package/dist/client/rest/api/UpgradeAPI.d.ts

@@ -12,7 +12,7 @@ export declare namespace ModuleVersion {
     }
 }
 export declare class UpgradeAPI extends BaseAPI {
-    appliedPlan(name: string, params?: Partial<PaginationOptions & APIParams>): Promise<number>;
-    currentPlan(params?: APIParams): Promise<Plan | undefined>;
-    moduleVersions(params?: APIParams): Promise<ModuleVersion[]>;
+    appliedPlan(name: string, params?: Partial<PaginationOptions & APIParams>, headers?: Record<string, string>): Promise<number>;
+    currentPlan(params?: APIParams, headers?: Record<string, string>): Promise<Plan | undefined>;
+    moduleVersions(params?: APIParams, headers?: Record<string, string>): Promise<ModuleVersion[]>;
 }