juno-network 0.4.0 → 0.5.0

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

@@ -0,0 +1,88 @@
+import { Coin } from "../../base/v1beta1/coin";
+import { Period } from "./vesting";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * MsgCreateVestingAccount defines a message that enables creating a vesting
+ * account.
+ */
+export interface MsgCreateVestingAccount {
+    from_address: string;
+    to_address: string;
+    amount: Coin[];
+    end_time: Long;
+    delayed: boolean;
+}
+/** MsgCreateVestingAccountResponse defines the Msg/CreateVestingAccount response type. */
+export interface MsgCreateVestingAccountResponse {
+}
+/**
+ * MsgCreatePermanentLockedAccount defines a message that enables creating a permanent
+ * locked account.
+ */
+export interface MsgCreatePermanentLockedAccount {
+    from_address: string;
+    to_address: string;
+    amount: Coin[];
+}
+/** MsgCreatePermanentLockedAccountResponse defines the Msg/CreatePermanentLockedAccount response type. */
+export interface MsgCreatePermanentLockedAccountResponse {
+}
+/**
+ * MsgCreateVestingAccount defines a message that enables creating a vesting
+ * account.
+ */
+export interface MsgCreatePeriodicVestingAccount {
+    from_address: string;
+    to_address: string;
+    start_time: Long;
+    vesting_periods: Period[];
+}
+/**
+ * MsgCreateVestingAccountResponse defines the Msg/CreatePeriodicVestingAccount
+ * response type.
+ */
+export interface MsgCreatePeriodicVestingAccountResponse {
+}
+export declare const MsgCreateVestingAccount: {
+    encode(message: MsgCreateVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateVestingAccount;
+    fromJSON(object: any): MsgCreateVestingAccount;
+    toJSON(message: MsgCreateVestingAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreateVestingAccount>): MsgCreateVestingAccount;
+};
+export declare const MsgCreateVestingAccountResponse: {
+    encode(_: MsgCreateVestingAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreateVestingAccountResponse;
+    fromJSON(_: any): MsgCreateVestingAccountResponse;
+    toJSON(_: MsgCreateVestingAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreateVestingAccountResponse>): MsgCreateVestingAccountResponse;
+};
+export declare const MsgCreatePermanentLockedAccount: {
+    encode(message: MsgCreatePermanentLockedAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePermanentLockedAccount;
+    fromJSON(object: any): MsgCreatePermanentLockedAccount;
+    toJSON(message: MsgCreatePermanentLockedAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreatePermanentLockedAccount>): MsgCreatePermanentLockedAccount;
+};
+export declare const MsgCreatePermanentLockedAccountResponse: {
+    encode(_: MsgCreatePermanentLockedAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePermanentLockedAccountResponse;
+    fromJSON(_: any): MsgCreatePermanentLockedAccountResponse;
+    toJSON(_: MsgCreatePermanentLockedAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreatePermanentLockedAccountResponse>): MsgCreatePermanentLockedAccountResponse;
+};
+export declare const MsgCreatePeriodicVestingAccount: {
+    encode(message: MsgCreatePeriodicVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePeriodicVestingAccount;
+    fromJSON(object: any): MsgCreatePeriodicVestingAccount;
+    toJSON(message: MsgCreatePeriodicVestingAccount): unknown;
+    fromPartial(object: DeepPartial<MsgCreatePeriodicVestingAccount>): MsgCreatePeriodicVestingAccount;
+};
+export declare const MsgCreatePeriodicVestingAccountResponse: {
+    encode(_: MsgCreatePeriodicVestingAccountResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgCreatePeriodicVestingAccountResponse;
+    fromJSON(_: any): MsgCreatePeriodicVestingAccountResponse;
+    toJSON(_: MsgCreatePeriodicVestingAccountResponse): unknown;
+    fromPartial(_: DeepPartial<MsgCreatePeriodicVestingAccountResponse>): MsgCreatePeriodicVestingAccountResponse;
+};

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

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

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

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgCreateVestingAccount, MsgCreateVestingAccountResponse, MsgCreatePermanentLockedAccount, MsgCreatePermanentLockedAccountResponse, MsgCreatePeriodicVestingAccount, MsgCreatePeriodicVestingAccountResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    createVestingAccount(request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse>;
+    createPermanentLockedAccount(request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse>;
+    createPeriodicVestingAccount(request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    createVestingAccount(request: MsgCreateVestingAccount): Promise<MsgCreateVestingAccountResponse>;
+    createPermanentLockedAccount(request: MsgCreatePermanentLockedAccount): Promise<MsgCreatePermanentLockedAccountResponse>;
+    createPeriodicVestingAccount(request: MsgCreatePeriodicVestingAccount): Promise<MsgCreatePeriodicVestingAccountResponse>;
+}

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

@@ -0,0 +1,97 @@
+import { BaseAccount } from "../../auth/v1beta1/auth";
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { Long, DeepPartial } from "@osmonauts/helpers";
+/**
+ * BaseVestingAccount implements the VestingAccount interface. It contains all
+ * the necessary fields needed for any vesting account implementation.
+ */
+export interface BaseVestingAccount {
+    base_account: BaseAccount;
+    original_vesting: Coin[];
+    delegated_free: Coin[];
+    delegated_vesting: Coin[];
+    end_time: Long;
+}
+/**
+ * ContinuousVestingAccount implements the VestingAccount interface. It
+ * continuously vests by unlocking coins linearly with respect to time.
+ */
+export interface ContinuousVestingAccount {
+    base_vesting_account: BaseVestingAccount;
+    start_time: Long;
+}
+/**
+ * DelayedVestingAccount implements the VestingAccount interface. It vests all
+ * coins after a specific time, but non prior. In other words, it keeps them
+ * locked until a specified time.
+ */
+export interface DelayedVestingAccount {
+    base_vesting_account: BaseVestingAccount;
+}
+/** Period defines a length of time and amount of coins that will vest. */
+export interface Period {
+    length: Long;
+    amount: Coin[];
+}
+/**
+ * PeriodicVestingAccount implements the VestingAccount interface. It
+ * periodically vests by unlocking coins during each specified period.
+ */
+export interface PeriodicVestingAccount {
+    base_vesting_account: BaseVestingAccount;
+    start_time: Long;
+    vesting_periods: Period[];
+}
+/**
+ * PermanentLockedAccount implements the VestingAccount interface. It does
+ * not ever release coins, locking them indefinitely. Coins in this account can
+ * still be used for delegating and for governance votes even while locked.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface PermanentLockedAccount {
+    base_vesting_account: BaseVestingAccount;
+}
+export declare const BaseVestingAccount: {
+    encode(message: BaseVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): BaseVestingAccount;
+    fromJSON(object: any): BaseVestingAccount;
+    toJSON(message: BaseVestingAccount): unknown;
+    fromPartial(object: DeepPartial<BaseVestingAccount>): BaseVestingAccount;
+};
+export declare const ContinuousVestingAccount: {
+    encode(message: ContinuousVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ContinuousVestingAccount;
+    fromJSON(object: any): ContinuousVestingAccount;
+    toJSON(message: ContinuousVestingAccount): unknown;
+    fromPartial(object: DeepPartial<ContinuousVestingAccount>): ContinuousVestingAccount;
+};
+export declare const DelayedVestingAccount: {
+    encode(message: DelayedVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DelayedVestingAccount;
+    fromJSON(object: any): DelayedVestingAccount;
+    toJSON(message: DelayedVestingAccount): unknown;
+    fromPartial(object: DeepPartial<DelayedVestingAccount>): DelayedVestingAccount;
+};
+export declare const Period: {
+    encode(message: Period, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Period;
+    fromJSON(object: any): Period;
+    toJSON(message: Period): unknown;
+    fromPartial(object: DeepPartial<Period>): Period;
+};
+export declare const PeriodicVestingAccount: {
+    encode(message: PeriodicVestingAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PeriodicVestingAccount;
+    fromJSON(object: any): PeriodicVestingAccount;
+    toJSON(message: PeriodicVestingAccount): unknown;
+    fromPartial(object: DeepPartial<PeriodicVestingAccount>): PeriodicVestingAccount;
+};
+export declare const PermanentLockedAccount: {
+    encode(message: PermanentLockedAccount, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): PermanentLockedAccount;
+    fromJSON(object: any): PermanentLockedAccount;
+    toJSON(message: PermanentLockedAccount): unknown;
+    fromPartial(object: DeepPartial<PermanentLockedAccount>): PermanentLockedAccount;
+};

package/types/codegen/cosmos_proto/bundle.d.ts

@@ -0,0 +1,24 @@
+import * as _1 from "./cosmos";
+export declare const cosmos_proto: {
+    scalarTypeFromJSON(object: any): _1.ScalarType;
+    scalarTypeToJSON(object: _1.ScalarType): string;
+    ScalarType: typeof _1.ScalarType;
+    ScalarTypeSDKType: typeof _1.ScalarTypeSDKType;
+    InterfaceDescriptor: {
+        encode(message: _1.InterfaceDescriptor, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _1.InterfaceDescriptor;
+        fromPartial(object: {
+            name?: string;
+            description?: string;
+        }): _1.InterfaceDescriptor;
+    };
+    ScalarDescriptor: {
+        encode(message: _1.ScalarDescriptor, writer?: import("protobufjs").Writer): import("protobufjs").Writer;
+        decode(input: Uint8Array | import("protobufjs").Reader, length?: number): _1.ScalarDescriptor;
+        fromPartial(object: {
+            name?: string;
+            description?: string;
+            fieldType?: _1.ScalarType[];
+        }): _1.ScalarDescriptor;
+    };
+};

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

@@ -0,0 +1,124 @@
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+export declare enum ScalarType {
+    SCALAR_TYPE_UNSPECIFIED = 0,
+    SCALAR_TYPE_STRING = 1,
+    SCALAR_TYPE_BYTES = 2,
+    UNRECOGNIZED = -1
+}
+export declare enum ScalarTypeSDKType {
+    SCALAR_TYPE_UNSPECIFIED = 0,
+    SCALAR_TYPE_STRING = 1,
+    SCALAR_TYPE_BYTES = 2,
+    UNRECOGNIZED = -1
+}
+export declare function scalarTypeFromJSON(object: any): ScalarType;
+export declare function scalarTypeToJSON(object: ScalarType): string;
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+export interface InterfaceDescriptor {
+    /**
+     * name is the name of the interface. It should be a short-name (without
+     * a period) such that the fully qualified name of the interface will be
+     * package.name, ex. for the package a.b and interface named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the interface and its
+     * purpose.
+     */
+    description: string;
+}
+/**
+ * InterfaceDescriptor describes an interface type to be used with
+ * accepts_interface and implements_interface and declared by declare_interface.
+ */
+export interface InterfaceDescriptorSDKType {
+    /**
+     * name is the name of the interface. It should be a short-name (without
+     * a period) such that the fully qualified name of the interface will be
+     * package.name, ex. for the package a.b and interface named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the interface and its
+     * purpose.
+     */
+    description: string;
+}
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ */
+export interface ScalarDescriptor {
+    /**
+     * name is the name of the scalar. It should be a short-name (without
+     * a period) such that the fully qualified name of the scalar will be
+     * package.name, ex. for the package a.b and scalar named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the scalar and its
+     * encoding format. For instance a big integer or decimal scalar should
+     * specify precisely the expected encoding format.
+     */
+    description: string;
+    /**
+     * field_type is the type of field with which this scalar can be used.
+     * Scalars can be used with one and only one type of field so that
+     * encoding standards and simple and clear. Currently only string and
+     * bytes fields are supported for scalars.
+     */
+    fieldType: ScalarType[];
+}
+/**
+ * ScalarDescriptor describes an scalar type to be used with
+ * the scalar field option and declared by declare_scalar.
+ * Scalars extend simple protobuf built-in types with additional
+ * syntax and semantics, for instance to represent big integers.
+ * Scalars should ideally define an encoding such that there is only one
+ * valid syntactical representation for a given semantic meaning,
+ * i.e. the encoding should be deterministic.
+ */
+export interface ScalarDescriptorSDKType {
+    /**
+     * name is the name of the scalar. It should be a short-name (without
+     * a period) such that the fully qualified name of the scalar will be
+     * package.name, ex. for the package a.b and scalar named C, the
+     * fully-qualified name will be a.b.C.
+     */
+    name: string;
+    /**
+     * description is a human-readable description of the scalar and its
+     * encoding format. For instance a big integer or decimal scalar should
+     * specify precisely the expected encoding format.
+     */
+    description: string;
+    /**
+     * field_type is the type of field with which this scalar can be used.
+     * Scalars can be used with one and only one type of field so that
+     * encoding standards and simple and clear. Currently only string and
+     * bytes fields are supported for scalars.
+     */
+    field_type: ScalarTypeSDKType[];
+}
+export declare const InterfaceDescriptor: {
+    encode(message: InterfaceDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): InterfaceDescriptor;
+    fromPartial(object: DeepPartial<InterfaceDescriptor>): InterfaceDescriptor;
+};
+export declare const ScalarDescriptor: {
+    encode(message: ScalarDescriptor, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ScalarDescriptor;
+    fromPartial(object: DeepPartial<ScalarDescriptor>): ScalarDescriptor;
+};