@initia/initia.js 0.2.20 → 0.2.22

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(groupId: number): Promise<GroupInfo>;
+    groupInfo(group_id: number): Promise<GroupInfo>;
     groupPolicyInfo(address: AccAddress): Promise<GroupPolicyInfo>;
-    groupMembers(groupId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupMember[], Pagination]>;
+    groupMembers(group_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupMember[], Pagination]>;
     groupsByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupInfo[], Pagination]>;
-    groupPoliciesByGroup(groupId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupPolicyInfo[], Pagination]>;
+    groupPoliciesByGroup(group_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupPolicyInfo[], Pagination]>;
     groupPoliciesByAdmin(admin: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupPolicyInfo[], Pagination]>;
-    proposal(proposalId: number): Promise<GroupProposal>;
+    proposal(proposal_id: number): Promise<GroupProposal>;
     proposalsByGroupPolicy(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupProposal[], Pagination]>;
-    voteByProposalVoter(proposalId: number, voter: AccAddress): Promise<GroupVote>;
-    votesByProposal(proposalId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[GroupVote[], 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(proposalId: number): Promise<GroupProposal.FinalTallyResult>;
+    tally(proposal_id: number): Promise<GroupProposal.FinalTallyResult>;
     groups(params?: Partial<PaginationOptions & APIParams>): Promise<[GroupInfo[], Pagination]>;
 }

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

@@ -37,11 +37,11 @@ export declare class IbcAPI extends BaseAPI {
     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(portId: string, channelId: string, sequences: number[], params?: APIParams): Promise<{
+    unreceivedPackets(port_id: string, channel_id: string, sequences: number[], params?: APIParams): Promise<{
         sequences: string[];
         height: Height;
     }>;
-    unreceivedAcks(portId: string, channelId: string, sequences: number[], params?: APIParams): Promise<{
+    unreceivedAcks(port_id: string, channel_id: string, sequences: number[], params?: APIParams): Promise<{
         sequences: string[];
         height: Height;
     }>;

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

@@ -5,6 +5,6 @@ export declare class IbcNftAPI extends BaseAPI {
     classTrace(hash: string): Promise<NftClassTrace>;
     classTraces(params?: Partial<PaginationOptions & APIParams>): Promise<[NftClassTrace[], Pagination]>;
     classHash(trace: string): Promise<string>;
-    parameters(params?: APIParams): Promise<IbcNftParams>;
     escrowAddress(channel_id: string, port_id: string, params?: APIParams): Promise<string>;
+    parameters(params?: APIParams): Promise<IbcNftParams>;
 }

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

@@ -8,5 +8,5 @@ export interface ChannelState {
 }
 export declare class IbcPermAPI extends BaseAPI {
     channelStates(params?: Partial<PaginationOptions & APIParams>): Promise<[ChannelState[], Pagination]>;
-    channelState(channelId: string, portId: string): Promise<ChannelState>;
+    channelState(channel_id: string, port_id: string): Promise<ChannelState>;
 }

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

@@ -1,16 +1,6 @@
 import { BaseAPI } from './BaseAPI';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
-import { DenomTrace } from '../../../core';
-export interface IbcTransferParams {
-    send_enabled: boolean;
-    receive_enabled: boolean;
-}
-export declare namespace IbcTransferParams {
-    interface Data {
-        send_enabled: boolean;
-        receive_enabled: boolean;
-    }
-}
+import { DenomTrace, IbcTransferParams } from '../../../core';
 export declare class IbcTransferAPI extends BaseAPI {
     denomTrace(hash: string): Promise<DenomTrace>;
     denomTraces(params?: Partial<PaginationOptions & APIParams>): Promise<[DenomTrace[], Pagination]>;

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

@@ -1,14 +1,6 @@
 import { BaseAPI } from './BaseAPI';
-import { AccAddress, Denom, MoveParams } from '../../../core';
+import { AccAddress, Denom, Module, MoveParams } from '../../../core';
 import { APIParams, Pagination, PaginationOptions } from '../APIRequester';
-import { UpgradePolicy } from '@initia/initia.proto/initia/move/v1/types';
-export interface Module {
-    address: AccAddress;
-    module_name: string;
-    abi: string;
-    raw_bytes: string;
-    upgrade_policy: UpgradePolicy;
-}
 export interface Resource {
     address: AccAddress;
     struct_tag: string;
@@ -46,25 +38,25 @@ export interface VMEvent {
 }
 export declare class MoveAPI extends BaseAPI {
     modules(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Module[], Pagination]>;
-    module(address: AccAddress, moduleName: string, params?: APIParams): Promise<Module>;
-    viewFunction<T>(address: AccAddress, moduleName: string, functionName: string, typeArgs?: string[], args?: string[]): Promise<T>;
-    view(address: AccAddress, moduleName: string, functionName: string, typeArgs?: string[], args?: string[]): Promise<ViewResponse>;
-    viewBatch(requests: ViewRequest[]): Promise<ViewResponse[]>;
-    viewJSON(address: AccAddress, moduleName: string, functionName: string, typeArgs?: string[], args?: string[]): Promise<ViewResponse>;
-    viewBatchJSON(requests: ViewRequest[]): Promise<ViewResponse[]>;
+    module(address: AccAddress, module_name: string, params?: APIParams): Promise<Module>;
     resources(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[{
         type: string;
         data: any;
     }[], Pagination]>;
-    resource<T>(address: AccAddress, structTag: string, params?: APIParams): Promise<{
+    resource<T>(address: AccAddress, struct_tag: string, params?: APIParams): 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>;
-    scriptABI(codeBytes: string): Promise<ABI>;
-    tableInfo(address: AccAddress, params?: APIParams): Promise<TableInfo>;
-    tableEntries(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[TableEntry[], Pagination]>;
-    tableEntry(address: AccAddress, keyBytes: string, params?: APIParams): Promise<TableEntry>;
 }

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

@@ -16,7 +16,7 @@ export declare class MstakingAPI extends BaseAPI {
     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, validatorSrc?: ValAddress, validatorDst?: ValAddress, _params?: Partial<PaginationOptions & APIParams>): Promise<[Redelegation[], Pagination]>;
+    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]>;
     validators(params?: Partial<PaginationOptions & APIParams>): Promise<[Validator[], Pagination]>;
     validator(validator: ValAddress, params?: APIParams): Promise<Validator>;

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

@@ -3,7 +3,7 @@ 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(validatorAddr: ValAddress, params?: APIParams): Promise<OpValidator>;
+    validator(validator_addr: ValAddress, params?: APIParams): Promise<OpValidator>;
     bridgeInfo(params?: APIParams): Promise<BridgeInfo>;
     nextL1Sequence(params?: APIParams): Promise<number>;
     nextL2Sequence(params?: APIParams): Promise<number>;

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

@@ -19,15 +19,15 @@ export declare namespace OutputInfo {
 }
 export declare class OphostAPI extends BaseAPI {
     bridgeInfos(params?: Partial<PaginationOptions & APIParams>): Promise<[BridgeInfo[], Pagination]>;
-    bridgeInfo(bridgeId: number, params?: APIParams): Promise<BridgeInfo>;
-    tokenPairs(bridgeId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[TokenPair[], Pagination]>;
-    tokenPairByL1Denom(bridgeId: number, l1Denom: string, params?: APIParams): Promise<TokenPair>;
-    tokenPairByL2Denom(bridgeId: number, l2Denom: string, params?: APIParams): Promise<TokenPair>;
-    lastFinalizedOutput(bridgeId: number, params?: Partial<PaginationOptions & APIParams>): Promise<OutputInfo>;
-    outputInfos(bridgeId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[OutputInfo[], Pagination]>;
-    outputInfo(bridgeId: number, outputIndex: number, params?: APIParams): Promise<OutputInfo>;
-    withdrawalClaimed(bridgeId: number, withdrawalHash: string, params?: APIParams): Promise<boolean>;
-    nextL1Sequence(bridgeId: number, params?: APIParams): Promise<number>;
-    batchInfos(bridgeId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[BatchInfoWithOutput[], 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>;
 }

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

@@ -1,26 +1,8 @@
 import { BaseAPI } from './BaseAPI';
-import { ValConsAddress, SlashingParams } from '../../../core';
-import { APIParams } from '../APIRequester';
-export interface SigningInfo {
-    address: ValConsAddress;
-    start_height: number;
-    index_offset: number;
-    jailed_until: Date;
-    tombstoned: boolean;
-    missed_blocks_counter: number;
-}
-export declare namespace SigningInfo {
-    interface Data {
-        address: string;
-        start_height: string;
-        index_offset: string;
-        jailed_until: string;
-        tombstoned: boolean;
-        missed_blocks_counter: string;
-    }
-}
+import { ValConsAddress, SlashingParams, ValidatorSigningInfo } from '../../../core';
+import { APIParams, Pagination } from '../APIRequester';
 export declare class SlashingAPI extends BaseAPI {
-    signingInfo(valConsAddress: ValConsAddress, params?: APIParams): Promise<SigningInfo>;
-    signingInfos(params?: APIParams): Promise<SigningInfo[]>;
+    signingInfos(params?: APIParams): Promise<[ValidatorSigningInfo[], Pagination]>;
+    signingInfo(val_cons_address: ValConsAddress, params?: APIParams): Promise<ValidatorSigningInfo>;
     parameters(params?: APIParams): Promise<SlashingParams>;
 }

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

@@ -164,7 +164,7 @@ export interface TxSearchOptions extends PaginationOptions {
 export declare class TxAPI extends BaseAPI {
     rest: RESTClient;
     constructor(rest: RESTClient);
-    txInfo(txHash: string, params?: APIParams): Promise<TxInfo>;
+    txInfo(tx_hash: string, params?: APIParams): Promise<TxInfo>;
     create(signers: SignerOptions[], options: CreateTxOptions): Promise<Tx>;
     txInfosByHeight(height: number | undefined): Promise<TxInfo[]>;
     estimateFee(signers: SignerData[], options: CreateTxOptions): Promise<Fee>;
@@ -173,13 +173,13 @@ export declare class TxAPI extends BaseAPI {
         signers?: SignerData[];
     }): Promise<string>;
     static encode(tx: Tx): string;
-    static decode(encodedTx: string): Tx;
+    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(moduleAddr: string, moduleName: string, startHeight: number, endHeight: number): Promise<Event[]>;
+    searchEvents(module_addr: string, module_name: string, start_height: number, end_height: number): Promise<Event[]>;
 }
 export {};

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

@@ -63,12 +63,12 @@ export declare namespace CodeInfo {
 export declare class WasmAPI extends BaseAPI {
     contractInfo(address: AccAddress, params?: APIParams): Promise<ContractInfo>;
     contractHistory(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[ContractCodeHistoryEntry[], Pagination]>;
-    contractsByCode(codeId: number, params?: Partial<PaginationOptions & APIParams>): Promise<[string[], Pagination]>;
+    contractsByCode(code_id: number, params?: Partial<PaginationOptions & APIParams>): Promise<[string[], Pagination]>;
     allContractState(address: AccAddress, params?: Partial<PaginationOptions & APIParams>): Promise<[Model[], Pagination]>;
-    rawContractState(address: AccAddress, queryData: string, params?: APIParams): Promise<string>;
-    smartContractState<T>(address: AccAddress, queryData: string, params?: APIParams): Promise<T>;
+    rawContractState(address: AccAddress, query_data: string, params?: APIParams): Promise<string>;
+    smartContractState<T>(address: AccAddress, query_data: string, params?: APIParams): Promise<T>;
     codeInfos(params?: Partial<PaginationOptions & APIParams>): Promise<[CodeInfo[], Pagination]>;
-    codeInfo(codeId: number, params?: APIParams): Promise<{
+    codeInfo(code_id: number, params?: APIParams): Promise<{
         code_info: CodeInfo;
         data: string;
     }>;

package/dist/core/Duration.d.ts

@@ -1,7 +1,6 @@
 import { Duration as Duration_pb } from '@initia/initia.proto/google/protobuf/duration';
-import { default as Long } from 'long';
 export declare class Duration {
-    seconds: Long;
+    seconds: number;
     nanos: number;
     constructor(seconds: number, nanos?: number);
     static fromString(str: string): Duration;

package/dist/core/auth/BaseAccount.d.ts

@@ -12,12 +12,12 @@ export declare class BaseAccount extends JSONSerializable<BaseAccount.Amino, Bas
     getAccountNumber(): number;
     getSequenceNumber(): number;
     getPublicKey(): PublicKey | undefined;
-    toAmino(): BaseAccount.Amino;
     static fromAmino(data: BaseAccount.Amino): BaseAccount;
+    toAmino(): BaseAccount.Amino;
     static fromData(data: BaseAccount.Data): BaseAccount;
     toData(): BaseAccount.Data;
-    toProto(): BaseAccount.Proto;
     static fromProto(baseAccountProto: BaseAccount.Proto): BaseAccount;
+    toProto(): BaseAccount.Proto;
     packAny(): Any;
     static unpackAny(pubkeyAny: Any): BaseAccount;
 }

package/dist/core/bank/msgs/MsgMultiSend.d.ts

@@ -34,24 +34,24 @@ export declare namespace MsgMultiSend {
     class Input extends JSONSerializable<Input.Amino, Input.Data, Input.Proto> {
         address: AccAddress;
         coins: Coins;
-        constructor(address: AccAddress, coinsInput: Coins.Input);
-        toAmino(): Input.Amino;
+        constructor(address: AccAddress, coins_input: Coins.Input);
         static fromAmino(data: Input.Amino): Input;
-        toData(): Input.Data;
+        toAmino(): Input.Amino;
         static fromData(data: Input.Data): Input;
-        toProto(): Input.Proto;
+        toData(): Input.Data;
         static fromProto(proto: Input.Proto): Input;
+        toProto(): Input.Proto;
     }
     class Output extends JSONSerializable<Output.Amino, Output.Data, Output.Proto> {
         address: AccAddress;
         coins: Coins;
-        constructor(address: AccAddress, coinsInput: Coins.Input);
-        toAmino(): Output.Amino;
+        constructor(address: AccAddress, coins_input: Coins.Input);
         static fromAmino(data: Output.Amino): Output;
-        toData(): Output.Data;
+        toAmino(): Output.Amino;
         static fromData(data: Output.Data): Output;
-        toProto(): Output.Proto;
+        toData(): Output.Data;
         static fromProto(proto: Output.Proto): Output;
+        toProto(): Output.Proto;
     }
     namespace Input {
         interface Amino {

package/dist/core/crisis/msgs/MsgVerifyInvariant.d.ts

@@ -4,9 +4,9 @@ import { MsgVerifyInvariant as MsgVerifyInvariant_pb } from '@initia/initia.prot
 import { AccAddress } from '../../bech32';
 export declare class MsgVerifyInvariant extends JSONSerializable<MsgVerifyInvariant.Amino, MsgVerifyInvariant.Data, MsgVerifyInvariant.Proto> {
     sender: AccAddress;
-    invariantModuleName: string;
-    invariantRoute: string;
-    constructor(sender: AccAddress, invariantModuleName: string, invariantRoute: string);
+    invariant_module_name: string;
+    invariant_route: string;
+    constructor(sender: AccAddress, invariant_module_name: string, invariant_route: string);
     static fromAmino(data: MsgVerifyInvariant.Amino): MsgVerifyInvariant;
     toAmino(): MsgVerifyInvariant.Amino;
     static fromData(data: MsgVerifyInvariant.Data): MsgVerifyInvariant;
@@ -21,15 +21,15 @@ export declare namespace MsgVerifyInvariant {
         type: 'cosmos-sdk/MsgVerifyInvariant';
         value: {
             sender: AccAddress;
-            invariantModuleName: string;
-            invariantRoute: string;
+            invariant_module_name: string;
+            invariant_route: string;
         };
     }
     interface Data {
         '@type': '/cosmos.crisis.v1beta1.MsgVerifyInvariant';
         sender: AccAddress;
-        invariantModuleName: string;
-        invariantRoute: string;
+        invariant_module_name: string;
+        invariant_route: string;
     }
     type Proto = MsgVerifyInvariant_pb;
 }

package/dist/core/gov/Vote.d.ts

@@ -33,8 +33,8 @@ export declare namespace Vote {
 }
 export declare class WeightedVoteOption extends JSONSerializable<WeightedVoteOption.Amino, WeightedVoteOption.Data, WeightedVoteOption.Proto> {
     option: VoteOption;
-    weight: string;
-    constructor(option: VoteOption, weight: number | string);
+    weight: number;
+    constructor(option: VoteOption, weight: number);
     static fromAmino(data: WeightedVoteOption.Amino): WeightedVoteOption;
     toAmino(): WeightedVoteOption.Amino;
     static fromData(data: WeightedVoteOption.Data): WeightedVoteOption;

package/dist/core/ibc/applications/transfer/index.d.ts

@@ -2,3 +2,4 @@ export * from './authorizations';
 export * from './msgs';
 export * from './DenomTrace';
 export * from './FungibleTokenPacketData';
+export * from './IbcTransferParams';

package/dist/core/ibc/core/client/index.d.ts

@@ -1,3 +1,4 @@
+export * from './msgs';
 export * from './ClientConsensusStates';
 export * from './ConsensusStateWithHeight';
 export * from './Height';

package/dist/core/ibc/core/client/msgs/tendermint/crypto.d.ts

@@ -4,9 +4,9 @@ import { PublicKey as PublicKey_pb } from '@initia/initia.proto/tendermint/crypt
 export declare class Proof extends JSONSerializable<any, Proof.Data, Proof.Proto> {
     total: number;
     index: number;
-    leafHash: string;
+    leaf_hash: string;
     aunts: string[];
-    constructor(total: number, index: number, leafHash: string, aunts: string[]);
+    constructor(total: number, index: number, leaf_hash: string, aunts: string[]);
     static fromAmino(_: any): Proof;
     toAmino(): any;
     static fromData(data: Proof.Data): Proof;

package/dist/core/ibc/core/client/msgs/tendermint/types.d.ts

@@ -3,23 +3,22 @@ import { Header as Header_pb, SignedHeader as SignedHeader_pb, BlockID as BlockI
 import { Validator as Validator_pb, ValidatorSet as ValidatorSet_pb, BlockIDFlag } from '@initia/initia.proto/tendermint/types/validator';
 import { Consensus } from './version';
 import { PublicKey } from './crypto';
-import { default as Long } from 'long';
 export declare class Header extends JSONSerializable<any, Header.Data, Header.Proto> {
     version: Consensus | undefined;
-    chainId: string;
-    height: string;
+    chain_id: string;
+    height: number;
     time: Date | undefined;
-    lastBlockId: BlockID | undefined;
-    lastCommitHash: string;
-    dataHash: string;
-    validatorsHash: string;
-    nextValidatorsHash: string;
-    consensusHash: string;
-    appHash: string;
-    lastResultsHash: string;
-    evidenceHash: string;
-    proposerAddress: string;
-    constructor(version: Consensus | undefined, chainId: string, height: string, time: Date | undefined, lastBlockId: BlockID | undefined, lastCommitHash: string, dataHash: string, validatorsHash: string, nextValidatorsHash: string, consensusHash: string, appHash: string, lastResultsHash: string, evidenceHash: string, proposerAddress: string);
+    last_block_id: BlockID | undefined;
+    last_commit_hash: string;
+    data_hash: string;
+    validators_hash: string;
+    next_validators_hash: string;
+    consensus_hash: string;
+    app_hash: string;
+    last_results_hash: string;
+    evidence_hash: string;
+    proposer_address: string;
+    constructor(version: Consensus | undefined, chain_id: string, height: number, time: Date | undefined, last_block_id: BlockID | undefined, last_commit_hash: string, data_hash: string, validators_hash: string, next_validators_hash: string, consensus_hash: string, app_hash: string, last_results_hash: string, evidence_hash: string, proposer_address: string);
     static fromAmino(_: any): Header;
     toAmino(): any;
     static fromData(data: Header.Data): Header;
@@ -66,8 +65,8 @@ export declare namespace SignedHeader {
 }
 export declare class BlockID extends JSONSerializable<any, BlockID.Data, BlockID.Proto> {
     hash: string;
-    partSetHeader?: PartSetHeader | undefined;
-    constructor(hash: string, partSetHeader?: PartSetHeader | undefined);
+    part_set_header?: PartSetHeader | undefined;
+    constructor(hash: string, part_set_header?: PartSetHeader | undefined);
     static fromAmino(_: any): BlockID;
     toAmino(): any;
     static fromData(data: BlockID.Data): BlockID;
@@ -101,11 +100,11 @@ export declare namespace PartSetHeader {
     type Proto = PartSetHeader_pb;
 }
 export declare class Commit extends JSONSerializable<any, Commit.Data, Commit.Proto> {
-    height: Long;
+    height: number;
     round: number;
-    blockId: BlockID | undefined;
+    block_id: BlockID | undefined;
     signatures: CommitSig[];
-    constructor(height: Long, round: number, blockId: BlockID | undefined, signatures: CommitSig[]);
+    constructor(height: number, round: number, block_id: BlockID | undefined, signatures: CommitSig[]);
     static fromAmino(_: any): Commit;
     toAmino(): any;
     static fromData(data: Commit.Data): Commit;
@@ -123,11 +122,11 @@ export declare namespace Commit {
     type Proto = Commit_pb;
 }
 export declare class CommitSig extends JSONSerializable<any, CommitSig.Data, CommitSig.Proto> {
-    blockIdFlag: BlockIDFlag;
-    validatorAddress?: string | undefined;
+    block_id_flag: BlockIDFlag;
+    validator_address?: string | undefined;
     timestamp?: Date | undefined;
     signature?: string | undefined;
-    constructor(blockIdFlag: BlockIDFlag, validatorAddress?: string | undefined, timestamp?: Date | undefined, signature?: string | undefined);
+    constructor(block_id_flag: BlockIDFlag, validator_address?: string | undefined, timestamp?: Date | undefined, signature?: string | undefined);
     static fromAmino(_: any): CommitSig;
     toAmino(): any;
     static fromData(data: CommitSig.Data): CommitSig;
@@ -147,8 +146,8 @@ export declare namespace CommitSig {
 export declare class ValidatorSet extends JSONSerializable<any, ValidatorSet.Data, ValidatorSet.Proto> {
     validators: Validator[];
     proposer: Validator | undefined;
-    totalVotingPower: Long;
-    constructor(validators: Validator[], proposer: Validator | undefined, totalVotingPower: Long);
+    total_voting_power: number;
+    constructor(validators: Validator[], proposer: Validator | undefined, total_voting_power: number);
     static fromAmino(_: any): ValidatorSet;
     toAmino(): any;
     static fromData(data: ValidatorSet.Data): ValidatorSet;
@@ -166,10 +165,10 @@ export declare namespace ValidatorSet {
 }
 export declare class Validator extends JSONSerializable<any, Validator.Data, Validator.Proto> {
     address: string;
-    pubKey: PublicKey | undefined;
-    votingPower: Long;
-    proposerPriority: Long;
-    constructor(address: string, pubKey: PublicKey | undefined, votingPower: Long, proposerPriority: Long);
+    pub_key: PublicKey | undefined;
+    voting_power: number;
+    proposer_priority: number;
+    constructor(address: string, pub_key: PublicKey | undefined, voting_power: number, proposer_priority: number);
     static fromAmino(_: any): Validator;
     toAmino(): any;
     static fromData(data: Validator.Data): Validator;

package/dist/core/ibc/lightclient/tendermint/Header.d.ts

@@ -4,11 +4,11 @@ import { Height } from '../../core/client/Height';
 import { SignedHeader, ValidatorSet } from '../../core/client/msgs/tendermint/types';
 import { Any } from '@initia/initia.proto/google/protobuf/any';
 export declare class Header extends JSONSerializable<any, Header.Data, Header.Proto> {
-    signedHeader?: SignedHeader | undefined;
-    validatorSet?: ValidatorSet | undefined;
-    trustedHeight?: Height | undefined;
-    trustedValidators?: ValidatorSet | undefined;
-    constructor(signedHeader?: SignedHeader | undefined, validatorSet?: ValidatorSet | undefined, trustedHeight?: Height | undefined, trustedValidators?: ValidatorSet | undefined);
+    signed_header?: SignedHeader | undefined;
+    validator_set?: ValidatorSet | undefined;
+    trusted_height?: Height | undefined;
+    trusted_validators?: ValidatorSet | undefined;
+    constructor(signed_header?: SignedHeader | undefined, validator_set?: ValidatorSet | undefined, trusted_height?: Height | undefined, trusted_validators?: ValidatorSet | undefined);
     static fromAmino(_: any): Header;
     toAmino(): any;
     static fromData(data: Header.Data): Header;

package/dist/core/move/Module.d.ts

@@ -0,0 +1,36 @@
+import { JSONSerializable } from '../../util/json';
+import { AccAddress } from '../bech32';
+import { Module as Module_pb, UpgradePolicy } from '@initia/initia.proto/initia/move/v1/types';
+export declare class Module extends JSONSerializable<Module.Amino, Module.Data, Module.Proto> {
+    address: AccAddress;
+    module_name: string;
+    abi: string;
+    raw_bytes: string;
+    upgrade_policy: Module.Policy;
+    constructor(address: AccAddress, module_name: string, abi: string, raw_bytes: string, upgrade_policy: Module.Policy);
+    static fromAmino(data: Module.Amino): Module;
+    toAmino(): Module.Amino;
+    static fromData(data: Module.Data): Module;
+    toData(): Module.Data;
+    static fromProto(data: Module.Proto): Module;
+    toProto(): Module.Proto;
+}
+export declare namespace Module {
+    type Policy = UpgradePolicy;
+    const Policy: typeof UpgradePolicy;
+    interface Amino {
+        address: AccAddress;
+        module_name: string;
+        abi: string;
+        raw_bytes: string;
+        upgrade_policy: string;
+    }
+    interface Data {
+        address: AccAddress;
+        module_name: string;
+        abi: string;
+        raw_bytes: string;
+        upgrade_policy: string;
+    }
+    type Proto = Module_pb;
+}

package/dist/core/move/index.d.ts

@@ -1,2 +1,3 @@
 export * from './msgs';
+export * from './Module';
 export * from './MoveParams';

package/dist/core/move/msgs/MsgExecute.d.ts

@@ -12,12 +12,12 @@ export declare class MsgExecute extends JSONSerializable<MsgExecute.Amino, MsgEx
     constructor(sender: AccAddress, module_address: AccAddress, module_name: string, function_name: string, type_args?: string[], args?: string[]);
     static fromAmino(data: MsgExecute.Amino): MsgExecute;
     toAmino(): MsgExecute.Amino;
+    static fromData(data: MsgExecute.Data): MsgExecute;
+    toData(): MsgExecute.Data;
     static fromProto(data: MsgExecute.Proto): MsgExecute;
     toProto(): MsgExecute.Proto;
     packAny(): Any;
     static unpackAny(msgAny: Any): MsgExecute;
-    static fromData(data: MsgExecute.Data): MsgExecute;
-    toData(): MsgExecute.Data;
 }
 export declare namespace MsgExecute {
     interface Amino {

package/dist/core/move/msgs/MsgPublish.d.ts

@@ -10,12 +10,12 @@ export declare class MsgPublish extends JSONSerializable<MsgPublish.Amino, MsgPu
     constructor(sender: AccAddress, code_bytes: string[], upgrade_policy: MsgPublish.Policy);
     static fromAmino(data: MsgPublish.Amino): MsgPublish;
     toAmino(): MsgPublish.Amino;
+    static fromData(data: MsgPublish.Data): MsgPublish;
+    toData(): MsgPublish.Data;
     static fromProto(proto: MsgPublish.Proto): MsgPublish;
     toProto(): MsgPublish.Proto;
     packAny(): Any;
     static unpackAny(msgAny: Any): MsgPublish;
-    static fromData(data: MsgPublish.Data): MsgPublish;
-    toData(): MsgPublish.Data;
 }
 export declare namespace MsgPublish {
     type Policy = UpgradePolicy;

package/dist/core/move/msgs/MsgScript.d.ts

@@ -10,12 +10,12 @@ export declare class MsgScript extends JSONSerializable<MsgScript.Amino, MsgScri
     constructor(sender: AccAddress, code_bytes: string, type_args?: string[], args?: string[]);
     static fromAmino(data: MsgScript.Amino): MsgScript;
     toAmino(): MsgScript.Amino;
+    static fromData(data: MsgScript.Data): MsgScript;
+    toData(): MsgScript.Data;
     static fromProto(data: MsgScript.Proto): MsgScript;
     toProto(): MsgScript.Proto;
     packAny(): Any;
     static unpackAny(msgAny: Any): MsgScript;
-    static fromData(data: MsgScript.Data): MsgScript;
-    toData(): MsgScript.Data;
 }
 export declare namespace MsgScript {
     interface Amino {

package/dist/core/mstaking/Redelegation.d.ts

@@ -40,12 +40,12 @@ export declare namespace Redelegation {
         shares_dst: Coins;
         balance: Coins;
         constructor(initial_balance: Coins.Input, balance: Coins.Input, shares_dst: Coins.Input, creation_height: number, completion_time: Date);
-        toAmino(): Entry.Amino;
         static fromAmino(data: Entry.Amino): Entry;
-        toData(): Entry.Data;
+        toAmino(): Entry.Amino;
         static fromData(data: Entry.Data): Entry;
-        toProto(): Entry.Proto;
+        toData(): Entry.Data;
         static fromProto(proto: Entry.Proto): Entry;
+        toProto(): Entry.Proto;
     }
     namespace Entry {
         interface Amino {