juno-network 0.4.0 → 0.5.0

package/types/codegen/cosmos/capability/v1beta1/capability.d.ts

@@ -0,0 +1,45 @@
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * Capability defines an implementation of an object capability. The index
+ * provided to a Capability must be globally unique.
+ */
+export interface Capability {
+    index: Long;
+}
+/**
+ * Owner defines a single capability owner. An owner is defined by the name of
+ * capability and the module name.
+ */
+export interface Owner {
+    module: string;
+    name: string;
+}
+/**
+ * CapabilityOwners defines a set of owners of a single Capability. The set of
+ * owners must be unique.
+ */
+export interface CapabilityOwners {
+    owners: Owner[];
+}
+export declare const Capability: {
+    encode(message: Capability, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Capability;
+    fromJSON(object: any): Capability;
+    toJSON(message: Capability): unknown;
+    fromPartial(object: DeepPartial<Capability>): Capability;
+};
+export declare const Owner: {
+    encode(message: Owner, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Owner;
+    fromJSON(object: any): Owner;
+    toJSON(message: Owner): unknown;
+    fromPartial(object: DeepPartial<Owner>): Owner;
+};
+export declare const CapabilityOwners: {
+    encode(message: CapabilityOwners, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): CapabilityOwners;
+    fromJSON(object: any): CapabilityOwners;
+    toJSON(message: CapabilityOwners): unknown;
+    fromPartial(object: DeepPartial<CapabilityOwners>): CapabilityOwners;
+};

package/types/codegen/cosmos/capability/v1beta1/genesis.d.ts

@@ -0,0 +1,34 @@
+import { CapabilityOwners } from "./capability";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/** GenesisOwners defines the capability owners with their corresponding index. */
+export interface GenesisOwners {
+    /** index is the index of the capability owner. */
+    index: Long;
+    /** index_owners are the owners at the given index. */
+    index_owners: CapabilityOwners;
+}
+/** GenesisState defines the capability module's genesis state. */
+export interface GenesisState {
+    /** index is the capability global index. */
+    index: Long;
+    /**
+     * owners represents a map from index to owners of the capability index
+     * index key is string to allow amino marshalling.
+     */
+    owners: GenesisOwners[];
+}
+export declare const GenesisOwners: {
+    encode(message: GenesisOwners, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisOwners;
+    fromJSON(object: any): GenesisOwners;
+    toJSON(message: GenesisOwners): unknown;
+    fromPartial(object: DeepPartial<GenesisOwners>): GenesisOwners;
+};
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};

package/types/codegen/cosmos/client.d.ts

@@ -0,0 +1,473 @@
+import { OfflineSigner, GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { AminoTypes, SigningStargateClient } from "@cosmjs/stargate";
+export declare const cosmosAminoConverters: {
+    "/cosmos.upgrade.v1beta1.MsgSoftwareUpgrade": {
+        aminoType: string;
+        toAmino: ({ authority, plan }: import("./upgrade/v1beta1/tx").MsgSoftwareUpgrade) => {
+            authority: string;
+            plan: {
+                name: string;
+                time: {
+                    seconds: string;
+                    nanos: number;
+                };
+                height: string;
+                info: string;
+                upgraded_client_state: {
+                    type_url: string;
+                    value: Uint8Array;
+                };
+            };
+        };
+        fromAmino: ({ authority, plan }: {
+            authority: string;
+            plan: {
+                name: string;
+                time: {
+                    seconds: string;
+                    nanos: number;
+                };
+                height: string;
+                info: string;
+                upgraded_client_state: {
+                    type_url: string;
+                    value: Uint8Array;
+                };
+            };
+        }) => import("./upgrade/v1beta1/tx").MsgSoftwareUpgrade;
+    };
+    "/cosmos.upgrade.v1beta1.MsgCancelUpgrade": {
+        aminoType: string;
+        toAmino: ({ authority }: import("./upgrade/v1beta1/tx").MsgCancelUpgrade) => {
+            authority: string;
+        };
+        fromAmino: ({ authority }: {
+            authority: string;
+        }) => import("./upgrade/v1beta1/tx").MsgCancelUpgrade;
+    };
+    "/cosmos.staking.v1beta1.MsgCreateValidator": {
+        aminoType: string;
+        toAmino: ({ description, commission, minSelfDelegation, delegatorAddress, validatorAddress, pubkey, value }: import("./staking/v1beta1/tx").MsgCreateValidator) => {
+            description: {
+                moniker: string;
+                identity: string;
+                website: string;
+                security_contact: string;
+                details: string;
+            };
+            commission: {
+                rate: string;
+                max_rate: string;
+                max_change_rate: string;
+            };
+            min_self_delegation: string;
+            delegator_address: string;
+            validator_address: string;
+            pubkey: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            value: {
+                denom: string;
+                amount: string;
+            };
+        };
+        fromAmino: ({ description, commission, min_self_delegation, delegator_address, validator_address, pubkey, value }: {
+            description: {
+                moniker: string;
+                identity: string;
+                website: string;
+                security_contact: string;
+                details: string;
+            };
+            commission: {
+                rate: string;
+                max_rate: string;
+                max_change_rate: string;
+            };
+            min_self_delegation: string;
+            delegator_address: string;
+            validator_address: string;
+            pubkey: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            value: {
+                denom: string;
+                amount: string;
+            };
+        }) => import("./staking/v1beta1/tx").MsgCreateValidator;
+    };
+    "/cosmos.staking.v1beta1.MsgEditValidator": {
+        aminoType: string;
+        toAmino: ({ description, validatorAddress, commissionRate, minSelfDelegation }: import("./staking/v1beta1/tx").MsgEditValidator) => {
+            description: {
+                moniker: string;
+                identity: string;
+                website: string;
+                security_contact: string;
+                details: string;
+            };
+            validator_address: string;
+            commission_rate: string;
+            min_self_delegation: string;
+        };
+        fromAmino: ({ description, validator_address, commission_rate, min_self_delegation }: {
+            description: {
+                moniker: string;
+                identity: string;
+                website: string;
+                security_contact: string;
+                details: string;
+            };
+            validator_address: string;
+            commission_rate: string;
+            min_self_delegation: string;
+        }) => import("./staking/v1beta1/tx").MsgEditValidator;
+    };
+    "/cosmos.staking.v1beta1.MsgDelegate": {
+        aminoType: string;
+        toAmino: ({ delegatorAddress, validatorAddress, amount }: import("./staking/v1beta1/tx").MsgDelegate) => {
+            delegator_address: string;
+            validator_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        };
+        fromAmino: ({ delegator_address, validator_address, amount }: {
+            delegator_address: string;
+            validator_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        }) => import("./staking/v1beta1/tx").MsgDelegate;
+    };
+    "/cosmos.staking.v1beta1.MsgBeginRedelegate": {
+        aminoType: string;
+        toAmino: ({ delegatorAddress, validatorSrcAddress, validatorDstAddress, amount }: import("./staking/v1beta1/tx").MsgBeginRedelegate) => {
+            delegator_address: string;
+            validator_src_address: string;
+            validator_dst_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        };
+        fromAmino: ({ delegator_address, validator_src_address, validator_dst_address, amount }: {
+            delegator_address: string;
+            validator_src_address: string;
+            validator_dst_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        }) => import("./staking/v1beta1/tx").MsgBeginRedelegate;
+    };
+    "/cosmos.staking.v1beta1.MsgUndelegate": {
+        aminoType: string;
+        toAmino: ({ delegatorAddress, validatorAddress, amount }: import("./staking/v1beta1/tx").MsgUndelegate) => {
+            delegator_address: string;
+            validator_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        };
+        fromAmino: ({ delegator_address, validator_address, amount }: {
+            delegator_address: string;
+            validator_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            };
+        }) => import("./staking/v1beta1/tx").MsgUndelegate;
+    };
+    "/cosmos.gov.v1beta1.MsgSubmitProposal": {
+        aminoType: string;
+        toAmino: ({ content, initialDeposit, proposer }: import("./gov/v1beta1/tx").MsgSubmitProposal) => {
+            content: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            initial_deposit: {
+                denom: string;
+                amount: string;
+            }[];
+            proposer: string;
+        };
+        fromAmino: ({ content, initial_deposit, proposer }: {
+            content: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            initial_deposit: {
+                denom: string;
+                amount: string;
+            }[];
+            proposer: string;
+        }) => import("./gov/v1beta1/tx").MsgSubmitProposal;
+    };
+    "/cosmos.gov.v1beta1.MsgVote": {
+        aminoType: string;
+        toAmino: ({ proposalId, voter, option }: import("./gov/v1beta1/tx").MsgVote) => {
+            proposal_id: string;
+            voter: string;
+            option: number;
+        };
+        fromAmino: ({ proposal_id, voter, option }: {
+            proposal_id: string;
+            voter: string;
+            option: number;
+        }) => import("./gov/v1beta1/tx").MsgVote;
+    };
+    "/cosmos.gov.v1beta1.MsgVoteWeighted": {
+        aminoType: string;
+        toAmino: ({ proposalId, voter, options }: import("./gov/v1beta1/tx").MsgVoteWeighted) => {
+            proposal_id: string;
+            voter: string;
+            options: {
+                option: number;
+                weight: string;
+            }[];
+        };
+        fromAmino: ({ proposal_id, voter, options }: {
+            proposal_id: string;
+            voter: string;
+            options: {
+                option: number;
+                weight: string;
+            }[];
+        }) => import("./gov/v1beta1/tx").MsgVoteWeighted;
+    };
+    "/cosmos.gov.v1beta1.MsgDeposit": {
+        aminoType: string;
+        toAmino: ({ proposalId, depositor, amount }: import("./gov/v1beta1/tx").MsgDeposit) => {
+            proposal_id: string;
+            depositor: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        };
+        fromAmino: ({ proposal_id, depositor, amount }: {
+            proposal_id: string;
+            depositor: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        }) => import("./gov/v1beta1/tx").MsgDeposit;
+    };
+    "/cosmos.gov.v1.MsgSubmitProposal": {
+        aminoType: string;
+        toAmino: ({ messages, initialDeposit, proposer, metadata }: import("./gov/v1/tx").MsgSubmitProposal) => {
+            messages: {
+                type_url: string;
+                value: Uint8Array;
+            }[];
+            initial_deposit: {
+                denom: string;
+                amount: string;
+            }[];
+            proposer: string;
+            metadata: string;
+        };
+        fromAmino: ({ messages, initial_deposit, proposer, metadata }: {
+            messages: {
+                type_url: string;
+                value: Uint8Array;
+            }[];
+            initial_deposit: {
+                denom: string;
+                amount: string;
+            }[];
+            proposer: string;
+            metadata: string;
+        }) => import("./gov/v1/tx").MsgSubmitProposal;
+    };
+    "/cosmos.gov.v1.MsgExecLegacyContent": {
+        aminoType: string;
+        toAmino: ({ content, authority }: import("./gov/v1/tx").MsgExecLegacyContent) => {
+            content: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            authority: string;
+        };
+        fromAmino: ({ content, authority }: {
+            content: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            authority: string;
+        }) => import("./gov/v1/tx").MsgExecLegacyContent;
+    };
+    "/cosmos.gov.v1.MsgVote": {
+        aminoType: string;
+        toAmino: ({ proposalId, voter, option, metadata }: import("./gov/v1/tx").MsgVote) => {
+            proposal_id: string;
+            voter: string;
+            option: number;
+            metadata: string;
+        };
+        fromAmino: ({ proposal_id, voter, option, metadata }: {
+            proposal_id: string;
+            voter: string;
+            option: number;
+            metadata: string;
+        }) => import("./gov/v1/tx").MsgVote;
+    };
+    "/cosmos.gov.v1.MsgVoteWeighted": {
+        aminoType: string;
+        toAmino: ({ proposalId, voter, options, metadata }: import("./gov/v1/tx").MsgVoteWeighted) => {
+            proposal_id: string;
+            voter: string;
+            options: {
+                option: number;
+                weight: string;
+            }[];
+            metadata: string;
+        };
+        fromAmino: ({ proposal_id, voter, options, metadata }: {
+            proposal_id: string;
+            voter: string;
+            options: {
+                option: number;
+                weight: string;
+            }[];
+            metadata: string;
+        }) => import("./gov/v1/tx").MsgVoteWeighted;
+    };
+    "/cosmos.gov.v1.MsgDeposit": {
+        aminoType: string;
+        toAmino: ({ proposalId, depositor, amount }: import("./gov/v1/tx").MsgDeposit) => {
+            proposal_id: string;
+            depositor: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        };
+        fromAmino: ({ proposal_id, depositor, amount }: {
+            proposal_id: string;
+            depositor: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        }) => import("./gov/v1/tx").MsgDeposit;
+    };
+    "/cosmos.distribution.v1beta1.MsgSetWithdrawAddress": {
+        aminoType: string;
+        toAmino: ({ delegatorAddress, withdrawAddress }: import("./distribution/v1beta1/tx").MsgSetWithdrawAddress) => {
+            delegator_address: string;
+            withdraw_address: string;
+        };
+        fromAmino: ({ delegator_address, withdraw_address }: {
+            delegator_address: string;
+            withdraw_address: string;
+        }) => import("./distribution/v1beta1/tx").MsgSetWithdrawAddress;
+    };
+    "/cosmos.distribution.v1beta1.MsgWithdrawDelegatorReward": {
+        aminoType: string;
+        toAmino: ({ delegatorAddress, validatorAddress }: import("./distribution/v1beta1/tx").MsgWithdrawDelegatorReward) => {
+            delegator_address: string;
+            validator_address: string;
+        };
+        fromAmino: ({ delegator_address, validator_address }: {
+            delegator_address: string;
+            validator_address: string;
+        }) => import("./distribution/v1beta1/tx").MsgWithdrawDelegatorReward;
+    };
+    "/cosmos.distribution.v1beta1.MsgWithdrawValidatorCommission": {
+        aminoType: string;
+        toAmino: ({ validatorAddress }: import("./distribution/v1beta1/tx").MsgWithdrawValidatorCommission) => {
+            validator_address: string;
+        };
+        fromAmino: ({ validator_address }: {
+            validator_address: string;
+        }) => import("./distribution/v1beta1/tx").MsgWithdrawValidatorCommission;
+    };
+    "/cosmos.distribution.v1beta1.MsgFundCommunityPool": {
+        aminoType: string;
+        toAmino: ({ amount, depositor }: import("./distribution/v1beta1/tx").MsgFundCommunityPool) => {
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+            depositor: string;
+        };
+        fromAmino: ({ amount, depositor }: {
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+            depositor: string;
+        }) => import("./distribution/v1beta1/tx").MsgFundCommunityPool;
+    };
+    "/cosmos.bank.v1beta1.MsgSend": {
+        aminoType: string;
+        toAmino: ({ fromAddress, toAddress, amount }: import("./bank/v1beta1/tx").MsgSend) => {
+            from_address: string;
+            to_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        };
+        fromAmino: ({ from_address, to_address, amount }: {
+            from_address: string;
+            to_address: string;
+            amount: {
+                denom: string;
+                amount: string;
+            }[];
+        }) => import("./bank/v1beta1/tx").MsgSend;
+    };
+    "/cosmos.bank.v1beta1.MsgMultiSend": {
+        aminoType: string;
+        toAmino: ({ inputs, outputs }: import("./bank/v1beta1/tx").MsgMultiSend) => {
+            inputs: {
+                address: string;
+                coins: {
+                    denom: string;
+                    amount: string;
+                }[];
+            }[];
+            outputs: {
+                address: string;
+                coins: {
+                    denom: string;
+                    amount: string;
+                }[];
+            }[];
+        };
+        fromAmino: ({ inputs, outputs }: {
+            inputs: {
+                address: string;
+                coins: {
+                    denom: string;
+                    amount: string;
+                }[];
+            }[];
+            outputs: {
+                address: string;
+                coins: {
+                    denom: string;
+                    amount: string;
+                }[];
+            }[];
+        }) => import("./bank/v1beta1/tx").MsgMultiSend;
+    };
+};
+export declare const cosmosProtoRegistry: ReadonlyArray<[string, GeneratedType]>;
+export declare const getSigningCosmosClientOptions: () => {
+    registry: Registry;
+    aminoTypes: AminoTypes;
+};
+export declare const getSigningCosmosClient: ({ rpcEndpoint, signer }: {
+    rpcEndpoint: string;
+    signer: OfflineSigner;
+}) => Promise<SigningStargateClient>;

package/types/codegen/cosmos/crisis/v1beta1/genesis.d.ts

@@ -0,0 +1,18 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the crisis module's genesis state. */
+export interface GenesisState {
+    /**
+     * constant_fee is the fee used to verify the invariant in the crisis
+     * module.
+     */
+    constant_fee: Coin;
+}
+export declare const GenesisState: {
+    encode(message: GenesisState, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState;
+    fromJSON(object: any): GenesisState;
+    toJSON(message: GenesisState): unknown;
+    fromPartial(object: DeepPartial<GenesisState>): GenesisState;
+};

package/types/codegen/cosmos/crisis/v1beta1/tx.amino.d.ts

@@ -0,0 +1,17 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgVerifyInvariant } from "./tx";
+export interface AminoMsgVerifyInvariant extends AminoMsg {
+    type: "cosmos-sdk/MsgVerifyInvariant";
+    value: {
+        sender: string;
+        invariant_module_name: string;
+        invariant_route: string;
+    };
+}
+export declare const AminoConverter: {
+    "/cosmos.crisis.v1beta1.MsgVerifyInvariant": {
+        aminoType: string;
+        toAmino: ({ sender, invariant_module_name, invariant_route }: MsgVerifyInvariant) => AminoMsgVerifyInvariant["value"];
+        fromAmino: ({ sender, invariant_module_name, invariant_route }: AminoMsgVerifyInvariant["value"]) => MsgVerifyInvariant;
+    };
+};

package/types/codegen/cosmos/crisis/v1beta1/tx.d.ts

@@ -0,0 +1,25 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** MsgVerifyInvariant represents a message to verify a particular invariance. */
+export interface MsgVerifyInvariant {
+    sender: string;
+    invariant_module_name: string;
+    invariant_route: string;
+}
+/** MsgVerifyInvariantResponse defines the Msg/VerifyInvariant response type. */
+export interface MsgVerifyInvariantResponse {
+}
+export declare const MsgVerifyInvariant: {
+    encode(message: MsgVerifyInvariant, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgVerifyInvariant;
+    fromJSON(object: any): MsgVerifyInvariant;
+    toJSON(message: MsgVerifyInvariant): unknown;
+    fromPartial(object: DeepPartial<MsgVerifyInvariant>): MsgVerifyInvariant;
+};
+export declare const MsgVerifyInvariantResponse: {
+    encode(_: MsgVerifyInvariantResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgVerifyInvariantResponse;
+    fromJSON(_: any): MsgVerifyInvariantResponse;
+    toJSON(_: MsgVerifyInvariantResponse): unknown;
+    fromPartial(_: DeepPartial<MsgVerifyInvariantResponse>): MsgVerifyInvariantResponse;
+};

package/types/codegen/cosmos/crisis/v1beta1/tx.registry.d.ts

@@ -0,0 +1,36 @@
+import { GeneratedType, Registry } from "@cosmjs/proto-signing";
+import { MsgVerifyInvariant } from "./tx";
+export declare const registry: ReadonlyArray<[string, GeneratedType]>;
+export declare const load: (protoRegistry: Registry) => void;
+export declare const MessageComposer: {
+    encoded: {
+        verifyInvariant(value: MsgVerifyInvariant): {
+            typeUrl: string;
+            value: Uint8Array;
+        };
+    };
+    withTypeUrl: {
+        verifyInvariant(value: MsgVerifyInvariant): {
+            typeUrl: string;
+            value: MsgVerifyInvariant;
+        };
+    };
+    toJSON: {
+        verifyInvariant(value: MsgVerifyInvariant): {
+            typeUrl: string;
+            value: unknown;
+        };
+    };
+    fromJSON: {
+        verifyInvariant(value: any): {
+            typeUrl: string;
+            value: MsgVerifyInvariant;
+        };
+    };
+    fromPartial: {
+        verifyInvariant(value: MsgVerifyInvariant): {
+            typeUrl: string;
+            value: MsgVerifyInvariant;
+        };
+    };
+};

package/types/codegen/cosmos/crisis/v1beta1/tx.rpc.msg.d.ts

@@ -0,0 +1,11 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgVerifyInvariant, MsgVerifyInvariantResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    verifyInvariant(request: MsgVerifyInvariant): Promise<MsgVerifyInvariantResponse>;
+}