juno-network 0.0.2

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

@@ -0,0 +1,54 @@
+import { AminoMsg } from "@cosmjs/amino";
+import { MsgGrant, MsgExec, MsgRevoke } from "./tx";
+export interface AminoMsgGrant extends AminoMsg {
+    type: "cosmos-sdk/MsgGrant";
+    value: {
+        granter: string;
+        grantee: string;
+        grant: {
+            authorization: {
+                type_url: string;
+                value: Uint8Array;
+            };
+            expiration: {
+                seconds: string;
+                nanos: number;
+            };
+        };
+    };
+}
+export interface AminoMsgExec extends AminoMsg {
+    type: "cosmos-sdk/MsgExec";
+    value: {
+        grantee: string;
+        msgs: {
+            type_url: string;
+            value: Uint8Array;
+        }[];
+    };
+}
+export interface AminoMsgRevoke extends AminoMsg {
+    type: "cosmos-sdk/MsgRevoke";
+    value: {
+        granter: string;
+        grantee: string;
+        msg_type_url: string;
+    };
+}
+export declare const AminoConverter: {
+    "/cosmos.authz.v1beta1.MsgGrant": {
+        aminoType: string;
+        toAmino: ({ granter, grantee, grant }: MsgGrant) => AminoMsgGrant["value"];
+        fromAmino: ({ granter, grantee, grant }: AminoMsgGrant["value"]) => MsgGrant;
+    };
+    "/cosmos.authz.v1beta1.MsgExec": {
+        aminoType: string;
+        toAmino: ({ grantee, msgs }: MsgExec) => AminoMsgExec["value"];
+        fromAmino: ({ grantee, msgs }: AminoMsgExec["value"]) => MsgExec;
+    };
+    "/cosmos.authz.v1beta1.MsgRevoke": {
+        aminoType: string;
+        toAmino: ({ granter, grantee, msgTypeUrl }: MsgRevoke) => AminoMsgRevoke["value"];
+        fromAmino: ({ granter, grantee, msg_type_url }: AminoMsgRevoke["value"]) => MsgRevoke;
+    };
+};

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

@@ -0,0 +1,88 @@
+import { Grant } from "./authz";
+import { Any } from "../../../google/protobuf/any";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * MsgGrant is a request type for Grant method. It declares authorization to the grantee
+ * on behalf of the granter with the provided expiration time.
+ */
+export interface MsgGrant {
+    granter: string;
+    grantee: string;
+    grant: Grant;
+}
+/** MsgExecResponse defines the Msg/MsgExecResponse response type. */
+export interface MsgExecResponse {
+    results: Uint8Array[];
+}
+/**
+ * MsgExec attempts to execute the provided messages using
+ * authorizations granted to the grantee. Each message should have only
+ * one signer corresponding to the granter of the authorization.
+ */
+export interface MsgExec {
+    grantee: string;
+    /**
+     * Authorization Msg requests to execute. Each msg must implement Authorization interface
+     * The x/authz will try to find a grant matching (msg.signers[0], grantee, MsgTypeURL(msg))
+     * triple and validate it.
+     */
+    msgs: Any[];
+}
+/** MsgGrantResponse defines the Msg/MsgGrant response type. */
+export interface MsgGrantResponse {
+}
+/**
+ * MsgRevoke revokes any authorization with the provided sdk.Msg type on the
+ * granter's account with that has been granted to the grantee.
+ */
+export interface MsgRevoke {
+    granter: string;
+    grantee: string;
+    msgTypeUrl: string;
+}
+/** MsgRevokeResponse defines the Msg/MsgRevokeResponse response type. */
+export interface MsgRevokeResponse {
+}
+export declare const MsgGrant: {
+    encode(message: MsgGrant, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgGrant;
+    fromJSON(object: any): MsgGrant;
+    toJSON(message: MsgGrant): unknown;
+    fromPartial(object: DeepPartial<MsgGrant>): MsgGrant;
+};
+export declare const MsgExecResponse: {
+    encode(message: MsgExecResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgExecResponse;
+    fromJSON(object: any): MsgExecResponse;
+    toJSON(message: MsgExecResponse): unknown;
+    fromPartial(object: DeepPartial<MsgExecResponse>): MsgExecResponse;
+};
+export declare const MsgExec: {
+    encode(message: MsgExec, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgExec;
+    fromJSON(object: any): MsgExec;
+    toJSON(message: MsgExec): unknown;
+    fromPartial(object: DeepPartial<MsgExec>): MsgExec;
+};
+export declare const MsgGrantResponse: {
+    encode(_: MsgGrantResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgGrantResponse;
+    fromJSON(_: any): MsgGrantResponse;
+    toJSON(_: MsgGrantResponse): unknown;
+    fromPartial(_: DeepPartial<MsgGrantResponse>): MsgGrantResponse;
+};
+export declare const MsgRevoke: {
+    encode(message: MsgRevoke, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRevoke;
+    fromJSON(object: any): MsgRevoke;
+    toJSON(message: MsgRevoke): unknown;
+    fromPartial(object: DeepPartial<MsgRevoke>): MsgRevoke;
+};
+export declare const MsgRevokeResponse: {
+    encode(_: MsgRevokeResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): MsgRevokeResponse;
+    fromJSON(_: any): MsgRevokeResponse;
+    toJSON(_: MsgRevokeResponse): unknown;
+    fromPartial(_: DeepPartial<MsgRevokeResponse>): MsgRevokeResponse;
+};

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

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

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

@@ -0,0 +1,15 @@
+import { Rpc } from "@osmonauts/helpers";
+import { MsgGrant, MsgGrantResponse, MsgExec, MsgExecResponse, MsgRevoke, MsgRevokeResponse } from "./tx";
+/** Msg defines the RPC service */
+export interface Msg {
+    grant(request: MsgGrant): Promise<MsgGrantResponse>;
+    exec(request: MsgExec): Promise<MsgExecResponse>;
+    revoke(request: MsgRevoke): Promise<MsgRevokeResponse>;
+}
+export declare class MsgClientImpl implements Msg {
+    private readonly rpc;
+    constructor(rpc: Rpc);
+    grant(request: MsgGrant): Promise<MsgGrantResponse>;
+    exec(request: MsgExec): Promise<MsgExecResponse>;
+    revoke(request: MsgRevoke): Promise<MsgRevokeResponse>;
+}

package/types/codegen/cosmos/bank/v1beta1/authz.d.ts

@@ -0,0 +1,19 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/**
+ * SendAuthorization allows the grantee to spend up to spend_limit coins from
+ * the granter's account.
+ *
+ * Since: cosmos-sdk 0.43
+ */
+export interface SendAuthorization {
+    spendLimit: Coin[];
+}
+export declare const SendAuthorization: {
+    encode(message: SendAuthorization, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SendAuthorization;
+    fromJSON(object: any): SendAuthorization;
+    toJSON(message: SendAuthorization): unknown;
+    fromPartial(object: DeepPartial<SendAuthorization>): SendAuthorization;
+};

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

@@ -0,0 +1,144 @@
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** Params defines the parameters for the bank module. */
+export interface Params {
+    sendEnabled: SendEnabled[];
+    defaultSendEnabled: boolean;
+}
+/**
+ * SendEnabled maps coin denom to a send_enabled status (whether a denom is
+ * sendable).
+ */
+export interface SendEnabled {
+    denom: string;
+    enabled: boolean;
+}
+/** Input models transaction input. */
+export interface Input {
+    address: string;
+    coins: Coin[];
+}
+/** Output models transaction outputs. */
+export interface Output {
+    address: string;
+    coins: Coin[];
+}
+/**
+ * Supply represents a struct that passively keeps track of the total supply
+ * amounts in the network.
+ * This message is deprecated now that supply is indexed by denom.
+ */
+/** @deprecated */
+export interface Supply {
+    total: Coin[];
+}
+/**
+ * DenomUnit represents a struct that describes a given
+ * denomination unit of the basic token.
+ */
+export interface DenomUnit {
+    /** denom represents the string name of the given denom unit (e.g uatom). */
+    denom: string;
+    /**
+     * exponent represents power of 10 exponent that one must
+     * raise the base_denom to in order to equal the given DenomUnit's denom
+     * 1 denom = 10^exponent base_denom
+     * (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with
+     * exponent = 6, thus: 1 atom = 10^6 uatom).
+     */
+    exponent: number;
+    /** aliases is a list of string aliases for the given denom */
+    aliases: string[];
+}
+/**
+ * Metadata represents a struct that describes
+ * a basic token.
+ */
+export interface Metadata {
+    description: string;
+    /** denom_units represents the list of DenomUnit's for a given coin */
+    denomUnits: DenomUnit[];
+    /** base represents the base denom (should be the DenomUnit with exponent = 0). */
+    base: string;
+    /**
+     * display indicates the suggested denom that should be
+     * displayed in clients.
+     */
+    display: string;
+    /**
+     * name defines the name of the token (eg: Cosmos Atom)
+     *
+     * Since: cosmos-sdk 0.43
+     */
+    name: string;
+    /**
+     * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can
+     * be the same as the display.
+     *
+     * Since: cosmos-sdk 0.43
+     */
+    symbol: string;
+    /**
+     * URI to a document (on or off-chain) that contains additional information. Optional.
+     *
+     * Since: cosmos-sdk 0.46
+     */
+    uri: string;
+    /**
+     * URIHash is a sha256 hash of a document pointed by URI. It's used to verify that
+     * the document didn't change. Optional.
+     *
+     * Since: cosmos-sdk 0.46
+     */
+    uriHash: string;
+}
+export declare const Params: {
+    encode(message: Params, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Params;
+    fromJSON(object: any): Params;
+    toJSON(message: Params): unknown;
+    fromPartial(object: DeepPartial<Params>): Params;
+};
+export declare const SendEnabled: {
+    encode(message: SendEnabled, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SendEnabled;
+    fromJSON(object: any): SendEnabled;
+    toJSON(message: SendEnabled): unknown;
+    fromPartial(object: DeepPartial<SendEnabled>): SendEnabled;
+};
+export declare const Input: {
+    encode(message: Input, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Input;
+    fromJSON(object: any): Input;
+    toJSON(message: Input): unknown;
+    fromPartial(object: DeepPartial<Input>): Input;
+};
+export declare const Output: {
+    encode(message: Output, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Output;
+    fromJSON(object: any): Output;
+    toJSON(message: Output): unknown;
+    fromPartial(object: DeepPartial<Output>): Output;
+};
+export declare const Supply: {
+    encode(message: Supply, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Supply;
+    fromJSON(object: any): Supply;
+    toJSON(message: Supply): unknown;
+    fromPartial(object: DeepPartial<Supply>): Supply;
+};
+export declare const DenomUnit: {
+    encode(message: DenomUnit, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DenomUnit;
+    fromJSON(object: any): DenomUnit;
+    toJSON(message: DenomUnit): unknown;
+    fromPartial(object: DeepPartial<DenomUnit>): DenomUnit;
+};
+export declare const Metadata: {
+    encode(message: Metadata, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Metadata;
+    fromJSON(object: any): Metadata;
+    toJSON(message: Metadata): unknown;
+    fromPartial(object: DeepPartial<Metadata>): Metadata;
+};

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

@@ -0,0 +1,42 @@
+import { Params, Metadata } from "./bank";
+import { Coin } from "../../base/v1beta1/coin";
+import * as _m0 from "protobufjs/minimal";
+import { DeepPartial } from "@osmonauts/helpers";
+/** GenesisState defines the bank module's genesis state. */
+export interface GenesisState {
+    /** params defines all the paramaters of the module. */
+    params: Params;
+    /** balances is an array containing the balances of all the accounts. */
+    balances: Balance[];
+    /**
+     * supply represents the total supply. If it is left empty, then supply will be calculated based on the provided
+     * balances. Otherwise, it will be used to validate that the sum of the balances equals this amount.
+     */
+    supply: Coin[];
+    /** denom_metadata defines the metadata of the differents coins. */
+    denomMetadata: Metadata[];
+}
+/**
+ * Balance defines an account address and balance pair used in the bank module's
+ * genesis state.
+ */
+export interface Balance {
+    /** address is the address of the balance holder. */
+    address: string;
+    /** coins defines the different coins this balance holds. */
+    coins: 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;
+};
+export declare const Balance: {
+    encode(message: Balance, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Balance;
+    fromJSON(object: any): Balance;
+    toJSON(message: Balance): unknown;
+    fromPartial(object: DeepPartial<Balance>): Balance;
+};